Open-source project
thebaselab/codeapp avatar
thebaselab/codeapp

Code App: an iPad editor whose runtimes are forks maintained by the project

Building a full-fledged code editor for iPad

3,989 stars399 forksSwiftMIT

At a glance

What is it?
A native iPad code editor read through what it actually bundles: CPython, LLVM, PHP, Node and OpenJDK at pinned versions from forks under other people's accounts, a shell script that has to run before Xcode will build, and a feature plan where every line is checked.
Who is it for?
Code App fits an iPad user who needs a real editor with Git, a terminal and on device runtimes rather than a remote shell, and it does not fit anyone expecting current language versions, since the pinned runtimes are Python 3.9.2, Clang 14.0.0, PHP 8.3.2, Node 18.19.0 and OpenJDK 8. Before building, run downloadFrameworks.sh or the project will not compile, and plan to fetch binaries that are large.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 10 days ago.
What is it written in?
Mainly Swift, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • thebaselab/codeapp3,989 ★ · +25
Star history
Repository2026-09-242026-11-15
thebaselab/codeapp4k4k

25 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The build cannot start until a shell script has run

The build instructions are five steps and one of them is not Xcode:

code
git clone https://github.com/thebaselab/codeapp
./downloadFrameworks.sh
Open Code.xcodeproj

The remaining two steps are switching to the CodeUI target if you want to run on a simulator, and clicking build. So the repository as cloned does not contain what the project links against; a script at the root fetches it. There is a Dependencies/ directory in the tree, which is where those fetched pieces are expected to land, and the script is the only thing that populates it. This is the single most common way to lose an hour on this project, because Xcode opens cleanly, the targets look complete, and the failure arrives at link time rather than at clone time. Two separate Xcode project related files sit at the top level: Code.xcodeproj/ as a directory and CodeUI.plist beside it, which is the configuration used when you switch to the CodeUI target for the simulator.

Two targets, and the choice is only about the simulator

The target selection matters for one reason only, and the instruction is narrow: switch to CodeUI if you wish to run the app on a simulator. Nothing else in the visible text changes between targets, so the default target is the device build and the alternative exists so the app can be launched without hardware. The repository layout explains why there are two. CodeApp/ holds the application code, Extensions/ holds the extension targets that an app like this needs, CodeUITests/ holds the UI test bundle, and CodeUITests-style separation sits next to a separate set of language resource files in LanguageResources/. There is also a Gemfile and a Gemfile.lock at the root, which is unusual for a Swift project and points to build tooling written in Ruby, most likely for the release pipeline rather than the app. A fastlane/ directory sits alongside them, which is the usual tool for that, and PrivacyInfo.xcprivacy at the root is the app privacy manifest the App Store review process expects.

Every runtime is a fork, and four of the five are under other accounts

The bundled languages are not stock builds. The table at the end of the project description names five runtimes, and for each one a separate repository:

| Language | Version | |-----------------|-------------| | Python | 3.9.2 | | Clang | 14.0.0 | | PHP | 8.3.2 | | Node.js | 18.19.0 | | OpenJDK | 8 |

Three of those repositories are under the account named holzschu, for CPython and for llvm-project, and one is under bummoblizard for php-src, and one is under 1Conan for nodejs-mobile. Only the OpenJDK build repository is under thebaselab. So the project's dependence on its runtimes is a dependence on five upstream projects plus five fork maintainers, three of whom are not the project. The version spread is the other half of the story: Python 3.9.2 and Clang 14.0.0 date from 2022, OpenJDK 8 from 2015, and only PHP 8.3.2 and Node 18.19.0 are recent. For an app whose selling point is a local development environment, the runtime set is the ceiling on what you can actually run.

The feature plan is a checklist with everything already marked done

The plan section names VS Code as the design template and monaco-editor plus native code as the implementation, then lists eight capabilities. Version control is listed as Git clone, commits, diff editor, push, pull and gutter indicator. An embedded terminal with 70 or more commands. A local web development environment described as Node plus PHP. A built in Python runtime. A C and C++ runtime with WebAssembly using clang. Local Java with OpenJDK. SSH support. LSP support, specified as Python and Java. Every one of the eight lines carries a check mark, so the plan functions as a feature statement rather than a roadmap. Two files in the tree explain how much of that list is native rather than delegated: SwiftGit2/ is a Swift Git binding, and SwiftWS/ appears to be a WebSocket layer, which together suggest the Git features are implemented natively rather than by shelling out to a bundled git binary.

Terminal commands come from three dictionary files

The claim of 70 or more terminal commands is supported by files at the repository root rather than by anything in the app bundle. There is a commandDictionary.plist and an extraCommandsDictionary.plist, which is the pattern of a list of shell commands with their names and definitions kept in property list files that the app reads at run time. The splitting into two is the interesting part: one dictionary for the base set and one for additions, which means a user or a build can extend the command set without touching the original. That also means the command surface is data, not code, so it can be inspected and edited without recompiling. Two other root files support the runtime story rather than the editing one. cacert.pem is a bundled certificate authority bundle, which is what allows HTTPS requests from a built in Python or Node process on iOS where the system trust store is not available to third party runtimes, and Fonts/ holds bundled fonts for the editor and terminal themes, with a separate Themes/ directory for the colour schemes.

The source repository is not where the development plan lives

The repository's own account of itself is short. It contains the source code of the app, and it says the team works on issues, listens to feedback, and publishes the development plan there, with the plan published in the issue tracker rather than as a file. That is the second place the page points to for news, after TestFlight. Distribution is through the App Store and through TestFlight, with both links given at the top, and the documentation lives on its own domain rather than in the repository. What the repository does not contain is any build system beyond Xcode and the download script, any CI configuration beyond the .github directory, no test plan beyond the UI test bundle, and no changelog. Release history comes from the App Store side: three visible versions are 1.12.2 dated 2026-07-30 and labelled June 2026, 1.12.1 dated 2026-03-28 and labelled March 2026, and 1.12.0 dated 2026-03-07 and labelled February 2026, so the version number and the month in the release name do not always match the publication date.

GitHub in the tree is for the editor, not for contributing to it

The repository has a .github/ directory like any other project, but the Git features inside the app are a different thing entirely and are worth not confusing. Version control in the feature list means the app can clone, commit, diff, push and pull the user's own repositories on the device, with a gutter indicator in the editor showing changed lines. The dependency for that is the SwiftGit2 directory in the tree, a Swift binding to the Git implementation, so the app embeds Git rather than requiring a git binary on iOS, which the platform does not permit in the ordinary way. The practical consequence for anyone evaluating the app is that the Git feature works on real repositories without any extra setup, and the practical consequence for anyone reading the repository is that the code here is the editor, not the Git engine. The most recent commit is dated 2026-09-15, roughly three weeks before the current date, and the repository is not archived.

Editorial conclusion

Code App fits an iPad user who needs a real editor with Git, a terminal and on device runtimes rather than a remote shell, and it does not fit anyone expecting current language versions, since the pinned runtimes are Python 3.9.2, Clang 14.0.0, PHP 8.3.2, Node 18.19.0 and OpenJDK 8. Before building, run downloadFrameworks.sh or the project will not compile, and plan to fetch binaries that are large. If you intend to modify a runtime, note that the sources live in separate repositories, several under accounts other than the project's own.

Frequently asked questions

How do I build Code App from source?

Clone github.com/thebaselab/codeapp, run ./downloadFrameworks.sh, open Code.xcodeproj, switch to the CodeUI target if you want to run on a simulator, and click build. The script is required because the repository does not ship the frameworks the project links against.

Which language runtimes does Code App bundle?

Five: Python 3.9.2, Clang 14.0.0, PHP 8.3.2, Node.js 18.19.0, and OpenJDK 8. Their sources are hosted in separate repositories, three of them under other accounts rather than the project's.

What editing features does Code App provide on iPad?

It uses VS Code as a design template with monaco-editor and native code. The listed features cover version control with clone, commits, a diff editor, push, pull and a gutter indicator, an embedded terminal with 70 or more commands, SSH support, and LSP support for Python and Java.

How do I get the Code App for iPad?

It is available on the App Store and through TestFlight, with both links given at the top of the project page. Documentation is hosted separately at code.thebaselab.com rather than in the repository.

How does Code App handle HTTPS from its bundled runtimes?

The repository carries a cacert.pem at its root, a bundled certificate authority file. That is what lets a built in Python or Node process make HTTPS requests on iOS, where the system trust store is not reachable from third party runtimes.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. Releases
  5. thebaselab/codeapp on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/thebaselab-codeapp.svg)](https://hysenlabs.com/projects/thebaselab-codeapp)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/thebaselab-codeapp.svg)](https://hysenlabs.com/projects/thebaselab-codeapp)

Was this useful?