One free desktop app that installs a complete toolchain, watches the machine live, draws every process, port, service, model and repository as one graph, makes environments from a sentence, and answers through AEDi — the Ionity local core, powered by Ollama on your own machine.
No wizards to babysit, no half-finished PATH. Pick a profile, press go, walk away.
Over a hundred curated packages across runtimes, IDEs, shells, databases, embedded, ML and MCP tooling — resolved to winget, Chocolatey or Homebrew per machine.
Checks GitHub Releases on its own schedule, verifies each download against the published SHA-256, and updates itself in place.
A tray monitor for CPU, memory, disk and network, with live probing so you find out something broke before your build does.
Registry repair, PATH reconstruction and a dry-run mode that shows exactly what would change before a single byte moves.
Tick AEDi local core in Software and Ollama plus a starter model are installed with everything else. The chip in the top bar always says which model is answering — or that none is yet. Nothing leaves the machine.
Node standard library only. Nothing to audit but the code you can already read, under Policy 986 AED.
ProGramerly opens in the IONITY Ai-OS operator layout: one ask box wired to AEDi, the workstation DOME — five strata, 26 segments, drillable — stats, tiles and a dock. Every percentage on the dome says whether it is measured, computed, an assessment or state; nothing is scored from a constant.
Three new workspaces, one honest AI, and a rebuilt intro in Ionity Global branding.
The machine as a living graph: processes (including the session-0 ones a task list hides), listening ports, services, volumes, Ollama and its models, environments and repositories — joined by the relations that exist right now, drawn as gradient paths with flow. Click anything: its facts, its actions, and Ask AEDi about it.
Make a Python venv, a uv venv, a conda env, a Node project or a Docker compose stack — by hand, or by telling AEDi what you need and confirming the recipe it drafts. Real commands stream back; nothing is reported as created until its marker file is there. Packages, freeze, compose up/down, terminal here, remove.
Every process, every service, every startup entry (Run keys, Startup folders, scheduled tasks) and every listening socket, read from the OS itself. End a process, start / stop / restart a service, disable a startup entry — it is backed up first and can be put back with one click.
AEDi is the Ionity intelligence layer; Ollama is the engine under it, and the app says so everywhere the name appears. When no model is present the ask box, the orb and every Ask button say so — there is no canned answer, anywhere.
Every DOME score now names its source. Two segments that were silently dead (Doctor findings, reclaimable space) read again. The resolver segment probes winget, Chocolatey, Homebrew and uv. The standby list is read from the real performance counters. A model pull that fails says failed, never skipped.
Every release boots the actual Electron app on GitHub's runners and drives it — 33 checks, including creating and removing a real venv through the surface. The screenshots below are from that run.
Every build is produced on GitHub's own runners — Windows on windows-latest,
macOS on Apple's toolchain, Linux on ubuntu-latest — and published with a
SHA256.txt you can check before you run anything.
| Platform | File | Get it |
|---|---|---|
| Windows 10/11 (x64) | ProGramerly-Setup-*-x64.exe | Latest release |
| Windows (ARM64) | ProGramerly-Setup-*-arm64.exe | Latest release |
| Windows portable | ProGramerly-Portable-*.exe | Latest release |
| macOS (Apple Silicon) | ProGramerly-*-arm64.dmg | Latest release |
| macOS (Intel) | ProGramerly-*-x64.dmg | Latest release |
| Linux (any distro) | ProGramerly-*.AppImage | Latest release |
| Debian / Ubuntu | programerly_*_amd64.deb | Latest release |
| Fedora / RHEL / openSUSE | programerly-*.x86_64.rpm | Latest release |
| Checksums | SHA256.txt | Latest release |
Builds are currently unsigned: Windows shows “Windows protected your PC” → More info → Run anyway,
and macOS asks for right-click → Open the first time. On Linux nothing gets in your way — mark the
AppImage executable with chmod +x and run it, or install the package with
sudo apt install ./programerly_*_amd64.deb / sudo dnf install ./programerly-*.rpm.
Signing turns on automatically the moment the certificates are added to the repository secrets.
ProGramerly is the combined workstation: the Ionity tools below are built into it as capabilities of the Command Center, not shipped as separate downloads. They arrive with the Windows release, are pinned by size and SHA-256 inside the app, and are verified every time before they run.
Every fan channel with live RPM and duty, every temperature source, and a curve editor that shows what a curve would command beside what the fan is actually doing. Curves are designed and stored here; the driver-level apply belongs to the Ionity FanControl build (Fanzi).
ProGramerly is the IONITY Ai-OS shell: top bar, ask box, workstation dome, stats, tiles and dock — with every workspace opening as an app window over the deck.
The IONITY CiC workstation utility, one tile away in the Command Center.
The machine as navigable structure: Hardware, System, Storage, Toolchain, Intelligence — 26 segments, each bound to a real data set, scored live. 34 sets are registered as readable by AEDi, each tagged measured, catalogue, manifest, state or computed, so every figure it quotes can be traced. Fourteen standing presets — including what is running, seen and unseen and what starts by itself.
AEDi answers through Ollama with a small default model (llama3.2:1b, about 1.3 GB, runs on CPU) so the copilot answers on a laptop without sending anything anywhere. Gemma is first class — gemma4:e2b for everyday work, gemma3:1b for quick triage, gemma4:e4b where the memory is there — and every curated model declares what it is for: chat, code, reasoning, vision or embeddings.
A workspace that turns a page, a screenshot or a PDF into text on this machine. Two kinds of reader, side by side, and the answer names which one produced it: an OCR engine (Tesseract, RapidOCR, EasyOCR) returns the characters it found; a tiny vision model (moondream, granite3.2-vision) reads layout and handwriting and can be asked a question about the page instead of transcribing it. PDFs are rendered at 200 dpi and read page by page. Nothing is uploaded to be read.
As soon as the shell is up, the local model reads the registered sets and reports on the deck — which model answered, how many sets it read, and the figures it took from each. Every workspace carries its own Ask control scoped to what that workspace covers, every preset is one click from the dock orb, and the whole dome can be written out as a Markdown report.