Old and new apps, via modern coding agents

Fields Medalist Terence Tao published a blog post on July 11, 2026 documenting how he used modern LLM-based coding agents to resurrect an old apps list — roughly two dozen Java 1.0 educational applets written in 1999 — and ship entirely new interactive tools in the same workflow. It's one of the most technically credible public case studies yet published on AI-assisted software modernization: a domain expert porting well-understood legacy code, verifying correctness against known mathematical results, and documenting every meaningful decision along the way. Whether you're researching old apps via modern coding agents, hunting for old apps download options, or trying to figure out how to install old apps on Android 14 and Android 16, Tao's account offers both a concrete model and an honest look at where the limits still lie.

The Old Apps List: Java Applets From 1999 That Stopped Working

Tao's old apps were interactive mathematical visualizations built for university courses around the turn of the millennium. Written in Java 1.0, they originally ran as browser applets embedded in HTML pages. Among the specific tools on his old apps list:

• Honeycomb applet — co-written with mathematician Allen Knutson in 1999; Tao describes it as "particularly tricky to code by hand"
• Besicovitch set applet — originally rendered in monochrome; colorized during the AI-assisted port
• Complex analysis applets — a suite of interactive tools built for a complex analysis course
• Linear algebra applets — interactive visualizations built for a linear algebra course

The entire old apps list became non-functional for a simple and irreversible reason: web standards dropped support for Java 1.0 applets. This wasn't a compatibility gap a settings change could bridge — it was a platform-level abandonment across every major browser. The only realistic paths forward were either a compatibility shim running the original bytecode inside an emulation layer, or a full language port. Tao chose the latter, with an AI agent as the primary coder.

How Modern Coding Agents Handled the Port

The porting method Tao describes — which he calls "vibe coding", a term coined by AI researcher Andrej Karpathy in February 2025 to describe fully conversational, intuition-driven development with an LLM agent — proceeded without a formal specification document. Tao adopted the term for his own workflow, though his practice was more deliberate than Karpathy's original framing: he reviewed agent output, published full transcripts, and applied an explicit risk framework rather than accepting generated code uncritically. He fed the agent the original Java source code alongside the HTML pages that had embedded the applets; the agent extracted a functional specification directly from the structure of the old code before rewriting it in JavaScript. No specific JavaScript framework is named; Tao notes they simply "landed on Javascript" as the target language for maximum browser compatibility.

For the more complex apps, Tao's main structural guidance was to build in stages: get the mathematical engine working and unit-tested first, then build the graphical interface on top of it. He notes, though, that "even this the agent largely handled on its own." The agent's familiarity with standard mathematical operations — Gaussian elimination is one explicit example Tao cites — meant it could faithfully reconstruct algorithmic intent without Tao needing to re-specify every computation from scratch.

The headline finding on code quality came from a direct count of bugs introduced versus bugs discovered:

"Notoriously, LLM-based coding agents can create various blatant or subtle bugs in their code; but in the porting of these two dozen or so applets, I could only find one minor bug (the handling of a drag event in one of the complex analysis applets had unwanted behavior when dragging outside of the main box), and in fact the agent identified two bugs in the original code that I was not aware of, so it ended up being a net wash as far as code quality was concerned."

That net-zero exchange — one regression introduced, two latent defects caught in 25-year-old code — is a striking benchmark. Most human-to-human code reviews of a port this size would consider a similar ratio acceptable. The agent's two discoveries were bugs that had lived undetected in the original Java for over two decades, surfaced only because translating the code forced a line-by-line re-examination of the logic.

New Apps Built Alongside the Old Apps via Modern Coding Agents

Beyond porting the old apps list, Tao used the same "vibe coding" workflow to build entirely new interactive tools — apps he had previously conceived but never finished because the implementation complexity was too high to manage by hand alone.

The Special Relativity Visualization Tool

Tao describes this new app as "Inkscape, but in Minkowski space" — a vector drawing and visualization environment that operates in relativistic spacetime rather than Euclidean coordinates. He had begun writing Java code for it in 1999, before Inkscape itself existed, but abandoned the project when the codebase grew too complex to sustain manually. With an AI agent, he completed it in "a couple hours of vibe coding."

The tool stores all geometric data in a "laboratory" rest frame in the backend, a layer deliberately hidden from the public interface. This design preserves the principle of relativity from the user's perspective — the interface presents no privileged reference frame — and required genuine physics understanding to specify correctly, even if the agent handled the actual implementation. It's a clean example of the division of labor running through Tao's entire experiment: the human supplies domain knowledge and high-level design intent; the agent supplies working code.

The Gilbreath Conjecture Visualization

The Gilbreath conjecture, attributed to Norman Gilbreath who observed it in 1958, concerns the iterated absolute differences of the sequence of prime numbers: beginning with 2, 3, 5, 7, 11, …, each successive row is formed by taking the absolute differences of adjacent terms, and the conjecture holds that every row after the first begins with 1. It has been verified computationally for enormous ranges but remains unproven in general.

After publishing a blog post and an accompanying paper on the conjecture, Tao built an interactive visualization to make the pattern tangible for readers — something a static figure in a paper simply can't do. This took "another few hours of conversation" with the agent. Notably, Tao published the full transcripts of those development conversations alongside the finished tool, trimming only the most repetitive implementation-progress reports. Anyone curious about what old apps via modern coding agents actually looks like moment-to-moment can read through the workflow directly from those transcripts.

Random Variables App

A third new tool, mentioned in the post's comments as a work-in-progress, is a pre-alpha random variable visualization app published at https://teorth.github.io/tao-web/apps/random-variables.html. It follows the same pattern: a coding agent used to produce an interactive mathematical supplement for ongoing academic work, in hours rather than weeks. Even in pre-alpha form, its existence reinforces Tao's broader point — the marginal cost of producing a new interactive tool has dropped enough to make "build a visualization" a reasonable response to "I just finished a paper."

The Broader Implication: Language Lock-In Is Dissolving

Perhaps the most consequential observation in Tao's post is a single sentence about language portability:

"The precise language or spec that a given piece of software is written in has become far less relevant now that the friction and cost of porting from one language to another has gone down to nearly zero."

This claim rests on a concrete demonstration, not speculation. The old apps existed only as Java 1.0 source code and bytecode; they now run as JavaScript in any modern browser, with a functional specification that was implicit in the original code itself — extracted by the agent without Tao needing to write a single line of formal documentation first.

This has direct implications for what Tao calls "downside risk." Because the applets are visual aids — supplementary material for courses and papers, not mission-critical infrastructure — bugs are recoverable. He's explicit about this framing:

"I think I may add such interactive visualizations as supplements for future papers; as such supplements are not mission-critical to the core of the paper, I again feel that the downside risk of using guided interaction with LLM agents to generate such visualizations is acceptable."

Responses in the Hacker News discussion thread reinforced the same pattern while adding two important qualifications. First, commenters noted that AI agents are most defensible for "nice-to-haves" — tools where correct visual output matters more than long-term maintainability, and where audiences can tolerate occasional visual artifacts. Second, others warned that "correct visual output" is audience-dependent: a domain expert can spot a visualization that's actively misleading even when it looks completely plausible to a general reader. For mathematical visualizations in particular, a subtly wrong rendering of a theorem could propagate a misconception more effectively than an obviously broken one.

A separate thread in the Hacker News discussion raised Jevons paradox — the economic observation that as a resource becomes more efficiently used, total consumption of that resource tends to rise rather than fall — applied here to software engineering: if AI makes creating interactive software nearly free, total demand for such tools may rise faster than any cost savings accrue to individual developers. The implication is that coding agents won't reduce the aggregate amount of software engineering work — they'll shift it toward higher-level specification, review, and domain-validation tasks, while the volume of software produced expands substantially.

Two Competing Approaches to Running Old Apps via Modern Platforms

Tao's approach — full rewriting via AI agent — isn't the only way to access a legacy old apps list on modern systems. A competing approach, represented by CheerpJ, runs the original bytecode unchanged inside a browser-based JVM. The two strategies have distinct trade-offs worth understanding before choosing a path for any given old apps via modern download scenario:

Approach	Method	Fidelity to Original	Requires Source Code	Output Maintainability	Best For
AI-assisted rewrite (Tao's method)	LLM agent ports Java → JavaScript conversationally	High — net-zero bug exchange in Tao's trial (one introduced, two legacy bugs caught)	Yes (source code strongly preferred)	Modern, fully editable JavaScript	Open-source apps where long-term maintainability and modernization are the goal
CheerpJ (WebAssembly JVM)	Runs unmodified JARs in browser via WebAssembly	Exact — no recompilation, no translation	No (compiled bytecode sufficient)	None — original bytecode is unchanged	Closed-source or obfuscated apps; scenarios requiring instant revival with zero code modification

CheerpJ 4.0, released on April 23, 2025 by Leaning Technologies, was the first version to support both Java 8 and Java 11 targets in modern browsers via a full WebAssembly JVM bundled with OpenJDK. It requires zero code modification — it fetches and executes the original JAR file directly in the browser — and has been stress-tested against IntelliJ IDEA's approximately 400 MB of JAR files as a real-world complexity benchmark. A subsequent release, CheerpJ 4.1 (released May 28, 2025), added Java 17 in preview, ahead of full stable support planned for the CheerpJ 5.0 milestone. Looking further ahead, the CheerpJ roadmap targets Java 21 support by early 2026 and full Java LTS version parity by the end of 2026. The CheerpJ developer, commenting in the Hacker News thread, expressed candidly mixed feelings about AI agents "solving the problem via proper modernization" — an implicit acknowledgment that both approaches now compete directly for the same legacy-revival use case, and that a sufficiently capable coding agent could render bytecode compatibility layers unnecessary for any app whose source code is available.

How to Install Old Apps on Android 14 and Android 16: The APK Reality

While Tao's post is web-centric, the same fundamental compatibility crisis plays out on mobile platforms. Users searching for an old apps download for Android frequently discover that their Android 14 or Android 16 device — including current Samsung Galaxy hardware — refuses to install APK files built with a low targetSdkVersion. The pattern mirrors the Java applet story exactly: a platform security decision renders an entire category of old apps via modern Android hardware inaccessible, through no fault of the apps themselves.

The targetSdkVersion Wall

Starting with Android 14, Google enforced a system-level installation block on APKs whose targetSdkVersion falls below API level 23. The block lives in the Android platform itself, not in any manufacturer overlay — meaning old apps via modern Samsung devices are affected identically to stock Android builds. Samsung adds no additional hardware-level restriction, but it doesn't bypass the platform's enforcement either. For users researching how to install old apps on Android 14 or how to install old apps on Android 16, the documented options are:

1. ADB sideload with bypass flag — Using adb install --bypass-low-target-sdk-block from a connected computer to override the targetSdkVersion check at install time. This is the most reliable method for old apps via modern download scenarios and works without root, but requires a USB connection, Developer Options enabled on the device, and the Android platform tools installed on the host machine.
2. InstallWithOptions + Shizuku — The open-source InstallWithOptions app uses the Shizuku framework to run with elevated shell permissions entirely on-device, exposing a "Bypass Low Target SDK Block" option that appears only on Android 14 and above. No root access is required. Important caveat: Shizuku 13.6.0 has a documented incompatibility with Mediatek chipsets; users on Mediatek hardware should downgrade to version 13.5.4 or use a compatible fork such as thedjchi's Shizuku until an updated release incorporating the upstream fix is published.
3. APK manifest editing — Using an APK editor to modify the targetSdkVersion field inside the app's AndroidManifest.xml to a value of 31 or higher before installation. This is technically effective for old apps via modern APK workflows and requires no connected computer, but it may break apps that depend on older API behaviors, legacy permission models, or pre-API-31 system behaviors that have since been removed or restricted.
4. AI-assisted rewrite — The path Tao's experience most directly implies: rather than fighting the platform's restrictions, use a coding agent to port the old app to a modern web application or recompile it as a fresh Android build targeting a current SDK level. This is the most labor-intensive path upfront, but it's the only one that produces a properly maintainable, future-compatible result — and on Tao's timeline, "labor-intensive" may now mean a few hours of conversation rather than weeks of manual development.

For users asking specifically how to install old apps via modern Samsung interfaces, the same Developer Options prerequisites apply as on stock Android: USB debugging must be enabled, and on some Samsung One UI builds, the separate "USB Debugging (Security Settings)" toggle — found in a different submenu from the standard USB debugging switch — must also be explicitly activated before adb commands will be accepted from a host machine.

Key Takeaways

• Tao ported roughly two dozen Java 1.0 applets to JavaScript using conversational AI coding agents, achieving a net-zero bug exchange: one minor regression introduced, two previously unknown latent bugs discovered in the original 1999 code.
• Two entirely new apps — a special relativity Minkowski-space visualizer and a Gilbreath conjecture interactive tool — were built from scratch via the same "vibe coding" workflow (a term coined by Andrej Karpathy in February 2025 and adopted by Tao for his own practice), each taking only a few hours of conversation with the agent.
• Language lock-in is weakening. Tao's central claim is that the cost of porting between languages has dropped close to zero for open-source code, making the original implementation language increasingly irrelevant to long-term accessibility.
• Risk-tolerance framing is essential. AI-generated code is most defensible for supplementary, non-mission-critical tools. Both Tao and Hacker News commenters agree that human review gates remain necessary for production, safety-critical, or domain-sensitive systems — where a subtly wrong output can be more dangerous than an obviously broken one.
• Jevons paradox applies. As coding agents reduce the marginal cost of producing interactive software, demand for such tools will likely expand faster than any savings accrue — shifting engineering effort toward higher-level specification, domain validation, and review rather than eliminating it.
• Two parallel approaches exist for legacy web apps: AI-assisted rewriting (produces modern, maintainable JavaScript) versus bytecode compatibility layers like CheerpJ (zero modification, exact behavioral fidelity). The right choice depends on source code availability, long-term maintainability requirements, and whether the app is open-source.
• On Android 14 and Android 16, the targetSdkVersion enforcement wall (API level 23 minimum) is real and manufacturer-independent. Tools like InstallWithOptions via Shizuku provide a no-root on-device workaround, while ADB sideloading with the bypass flag remains the most broadly reliable method for old apps download scenarios requiring no code modification.
• CheerpJ's roadmap targets full Java LTS parity by end of 2026 (Java 17 preview already available in CheerpJ 4.1; Java 21 targeted for early 2026), offering a durable alternative lane for closed-source legacy code that can't be rewritten by any agent lacking access to the original source.

What Comes Next

Tao's experiment is a narrow but unusually credible data point — a Fields Medalist working with well-understood mathematical content and relatively simple UI logic, in a domain where correctness is verifiable against known results by someone with the expertise to check them. Those conditions won't always hold. As coding agents improve and context windows expand, similar workflows will increasingly be applied to larger and more complex old apps lists: scientific simulation packages, statistical toolkits, educational platforms, and domain-specific desktop applications whose original developers are no longer around to validate output.

CheerpJ's roadmap toward full Java LTS parity by the end of 2026 — with Java 17 preview already shipping in CheerpJ 4.1 and Java 21 support targeted for early 2026 — will offer a reliable alternative lane for closed-source legacy code that no agent can rewrite without source access. On mobile, the tension between platform security policy — which drives the targetSdkVersion wall on Android 14 and Android 16 — and user demand for old apps via modern Android hardware will persist until either the policy relaxes or AI-assisted recompilation makes producing a fully compliant rebuild trivially cheap. Given the trajectory Tao documents, the latter outcome looks increasingly plausible — and the timeline for reaching it measurably shorter than it did even a year ago.