Inside Uiua: the parser crate, the wasm pin, and a Rust floor the readme understates
A tacit array programming language
At a glance
- What is it?
- Uiua is a tacit array programming language whose interpreter, parser crate and browser site ship from one Rust workspace. The engineering worth reading sits in the pins: a readme that asks for Rust 1.88 next to a manifest that asks for 1.92.0, and feature flags that are off by default while the examples directory already assumes them.
- Who is it for?
- Uiua fits an engineer who already thinks in whole arrays and wants the browser to be a cheap way in, and it fits badly anyone who needs a pinned, reproducible toolchain today. Before committing, check two things on your own machine: whether your Rust clears the manifest floor of 1.92.0 rather than the readme's 1.88, and whether your programs need audio, webcam or window access, since a plain cargo install uiua leaves all three out.
- 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 1 day ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 23, 2026, and from our analysis. They are not legal advice.
Editorial analysis
One workspace holds the interpreter, the parser and the browser site
Uiua describes itself as a tacit array programming language, and the repository tags read apl, array-programming, rust, tacit and uiua. Tacit programming is code written without named variables, and the readme links the term to its Wikipedia article, which is the shortest way to see what a newcomer is agreeing to give up.
No single interpreter crate makes up the repository. Cargo.toml opens a workspace whose members are site, tests_ffi, pad/editor and parser, and the root package depends on uiua_parser through a path entry rather than a registry version, carrying the same 0.20.0-dev.1 string. Because that dependency is a path, the parser used at build time is the one sitting in this tree, so the grammar cannot quietly drift away from the interpreter that consumes it.
Next to those crates sit src/, examples/, tests/, tests_special/, nix/, flake.nix, flake.lock, rustfmt.toml and Cargo.lock. For an engineer sizing up adoption, that layout is the first hard fact. Grammar, browser front end and editor pad are all inside the same workspace, so a change to the language surface is a change to several crates at once, not a patch to one binary.
The site crate runs client side behind an exact wasm-bindgen pin
For the browser side, site is a workspace member whose dependency list is pinned tighter than the rest. leptos, leptos_meta and leptos_router all sit at 0.6.11, and both leptos_meta and leptos_router request the csr feature, the client-side rendering path. js-sys is at 0.3.69.
Then there is wasm-bindgen, written as =0.2.108. That leading equals sign makes it an exact pin, not a caret range, and the manifest carries a note reminding the reader that changing the wasm-bindgen version means changing it in nix/site.nix too. The online interpreter at uiua.org and the Nix build therefore share one locked wasm toolchain, and a bump is a two-file edit that a careless single-file edit breaks.
The web-sys feature array in the same manifest is long, naming Clipboard, FileReader, HtmlAudioElement, Performance, ResizeObserver, ScrollIntoViewOptions and more. DataTransfer is listed twice in that array, which tells you the array is edited by hand rather than generated, and a hand-kept list is where the next careless edit goes.
The readme asks for Rust 1.88 and the manifest asks for 1.92.0
The readme tells you that installing through Cargo requires Rust (>=1.88). Cargo.toml says something different: rust-version = "1.92.0", alongside edition = "2024".
A machine with a toolchain between those two versions clears the readme check and is still refused by the build, because Cargo reads the manifest field and never reads the prose. On a locked CI image, where the toolchain was pinned months ago by somebody else's upgrade policy, that gap costs an afternoon and a confusing error message.
The same part of the readme carries a warning for the Nix route: if you meet rustc or any other package version mismatch, the file to update is flake.lock, so the nix shell can pull newer dependencies. So there are three toolchain contracts in one repository, a number in the readme, a number in the manifest and a lockfile that has to be refreshed by hand, and only the middle one is enforced by a tool.
Four routes to a working interpreter, only one needs a toolchain
You can try the language with nothing installed on the website at uiua.org, which is also where the documentation, the examples and the online interpreter live. That hosted route is the real alternative to a local build, and the difference is specific: no Rust on the machine, no system libraries to install, and in exchange none of the optional features, because audio, webcam and window are compile-time flags rather than runtime settings. The hosted page is not the native interpreter either, and the built-in language server belongs to that native build.
If your operating system has a download, the readme points at a prebuilt binary. Otherwise the route runs through Cargo, and the two commands differ in what gets compiled in:
cargo install uiua -F full # Installs all features
cargo install uiua # No audio, webcam, or window featuresOn Linux the build wants system libraries first:
apt install libx11-dev libffi-devBuilding from the git repository instead of a published crate version is a third Cargo route:
cargo install --git https://github.com/uiua-lang/uiua uiua -F full
cargo install --git https://github.com/uiua-lang/uiua uiuaThe fourth route is the Nix one, and the readme expects you to clone the repository before running any of it:
nix develop # to drop into a shell prompt with all the dependencies
cargo check # to make sure you can compile/build latest version
cargo build # to build latest debug version of uiua
cargo run repl # to get uiua replnix develop gives you every dependency in one shell, cargo check confirms your compiler can build the current source, and cargo run repl is the shortest path to a prompt you can type into.
Feature flags decide which shipped examples you can actually run
Four feature names exist: full, audio, webcam and window. None of them is on unless you ask for it with --features, and full is only a shorthand for turning on the rest.
audio enables the audio system functions and may require libasound2-dev libudev-dev pkg-config on Linux. webcam enables the webcam system functions and may require libjpeg-dev there. window enables output in a window, and the Linux install step asks for libx11-dev and libffi-dev before any of this compiles.
That choice has a visible cost in examples/. The directory holds audio_play.ua, audio_stream.ua, photobooth.ua, logo_gif.ua and shuffle_music.ua right next to pure computation such as goldbach.ua, nqueens.ua and n-body.ua. An interpreter built by the bare cargo install uiua command has no audio, no webcam and no window, so the examples that depend on those capabilities stay out of reach until you rebuild with the flags. bad_apple.ua sits beside bad_apple_pots.ua, http_server.ua needs something no listed feature name describes, and life.ua, spiral.ua, markov.ua, yahtzee.ua, raw.ua and flag_blender.ua need nothing beyond the default build. The examples assume a full install; the quick command does not give you one.
Clippy settings keep print statements out of the library crates
The workspace switches clippy on with a lint table most projects never write down. cargo is set to warn with a priority of -1, the only entry in the table that carries a priority at all. dbg_macro is warn, so a leftover debug macro in the source becomes a warning rather than a surprise in a binary someone else runs. non_std_lazy_statics is warn, a lint about lazy statics pulled in from crates other than std.
print_stdout is warn as well, and that is the entry with teeth for an interpreter that also backs a browser site: it is the standard lint against print! and println! in library code, so anything left in a shared path surfaces as a warning.
Two entries are deliberately relaxed. multiple_crate_versions is allow, so duplicated dependency versions in the graph do not block anyone. negative_feature_names is allow, which buys room for feature names that read awkwardly. Neither setting is free, and the combination tells you the maintainers would rather keep building than spend a cycle unifying versions across four workspace crates and their optional features.
Editor support is a built-in language server and a separate font list
The native interpreter carries a built-in language server that editor extensions attach to, and a .vscode/ directory sits at the top of the repository. The readme does not name a single editor extension. It sends you to the website instead, where the extension list lives behind uiua.org/docs/install#editor-support.
The second link is the awkward one. Fonts that support Uiua's characters are catalogued behind uiua.org/docs/install#fonts, and a language that draws its syntax from special characters asks every machine in the chain, editor, terminal, remote shell, to carry a font with those characters in it. A missing glyph is not an error message. It is a wrong shape on screen that a reviewer may not notice until the code is wrong.
None of that is a blocker, and none of it is automatic. The interpreter gives you the protocol; the font is a separate install on each machine, and the readme does not document a way to check it.
Upgrade cost sits in the pins, the lockfile and the version gap
The last push was on 2026-09-26, the repository is not archived, and the licence declared identically in readme.md and Cargo.toml is MIT, a permissive grant whose one condition is that the notice travels with the code. That same manifest carries version = "0.20.0-dev.1" while the newest numbered build is 0.19.1 dated 2026-09-03, so the Cargo route and the binary download route do not hand you identical code, and a team that pins Uiua in a lockfile has to decide which of those two it means. Whether that grant satisfies your organisation is a question for whoever owns that policy, not for this repository.
Beyond those two numbers, the upgrade friction is mechanical. wasm-bindgen is exact-pinned and mirrored in nix/site.nix, the web-sys feature array is maintained by hand, Cargo.lock sits at the top of the tree, and two clippy lints are set to allow so duplicated dependency versions do not stop a build.
None of that is exotic, and all of it is spread over more than one file. A version bump here touches a manifest, a Nix file and a lockfile rather than a single line, which is the concrete cost to weigh before Uiua becomes a dependency in something that ships on a schedule of its own.
Editorial conclusion
Uiua fits an engineer who already thinks in whole arrays and wants the browser to be a cheap way in, and it fits badly anyone who needs a pinned, reproducible toolchain today. Before committing, check two things on your own machine: whether your Rust clears the manifest floor of 1.92.0 rather than the readme's 1.88, and whether your programs need audio, webcam or window access, since a plain cargo install uiua leaves all three out. If both clear, start on the website at uiua.org and move to a local build once the repl and the language server start to matter.
Frequently asked questions
Do I need Rust installed before I can try Uiua?
No. The readme says you can try the language without installing anything on the website at uiua.org, which also hosts the documentation, the examples and an online interpreter. A local interpreter comes either as a download for a supported operating system or through Cargo, and that second route needs Rust, with the readme putting the requirement at Rust (>=1.88).
Which Rust version does a Cargo build of Uiua actually require?
The readme names Rust (>=1.88), but Cargo.toml declares rust-version = "1.92.0" and edition = "2024". Cargo enforces the manifest field rather than the prose, so 1.92.0 is the number to plan against.
Can a default Uiua install play sound or open a window?
Not with a plain cargo install uiua, which the readme describes as having no audio, webcam or window features. Those are optional and off by default, enabled by passing --features <feature>, where audio may require libasound2-dev libudev-dev pkg-config on Linux and webcam may require libjpeg-dev.
Is there an editor extension for Uiua?
The native interpreter has a built-in language server that editor extensions can use. The readme does not name the extensions itself; the list sits at uiua.org/docs/install#editor-support and the matching font list at uiua.org/docs/install#fonts.
What is the uiua_parser crate inside the Uiua repository?
It is a separate workspace member that the root package depends on by path, sharing the root version string 0.20.0-dev.1. The same workspace lists site, tests_ffi and pad/editor as members, so the grammar, the browser front end and the editor pad are all built alongside the interpreter.
Official sources
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.
[](https://hysenlabs.com/projects/uiua-lang-uiua)Was this useful?