What it is

One LocalAI.exe (about 42 MB, no Python needed), a catalogue of 34 models (Qwen3, Gemma 3/3n, Llama 3.1/3.2, Mistral, Phi-4, DeepSeek-R1, Qwen2.5-Coder and -VL, LLaVA, gpt-oss), a streaming chat with a "think" mode and attachments, model moving, updates and a full uninstall. MIT licence. Chats never leave the PC: the app talks to Ollama on 127.0.0.1, and the network is only used for downloads and update checks.

Structure

I needed a small window and logic that digs into the system (registry, processes, installers), so: Python, with a plain HTML/CSS/JS interface and no bundler.

• main.py starts a local HTTP server on 127.0.0.1 and opens a pywebview window (WebView2). If that fails, it falls back to Edge or Chrome with --app.
• server.py is the API for the UI: state, install, chat, updates, paths. Requests are protected by a session token (X-Token) and a Host check, so a page in your browser cannot call the local server.
• hw.py detects hardware, catalog.py holds the model catalogue and the recommendation, engine.py does everything about Ollama.
• ui/ is the page, styles and app.js with a tiny Markdown renderer. Strings live in i18n.js in two languages.

Hardware without WMI

WMI is broken on my PC, and that happens elsewhere too, so detection avoids it:

• NVIDIA: nvidia-smi --query-gpu=name,memory.total;
• other GPUs: the display-class registry key (DriverDesc, HardwareInformation.qwMemorySize); the value can be negative from a 32-bit overflow and has to be corrected;
• RAM: GlobalMemoryStatusEx via ctypes.

Free space is measured on the drive of the models folder, not on C:, because the user can move it.

Picking a model

Each entry has a size in GiB and its capabilities. A model needs more than its file size (context, buffers), so the estimate is rough but simple:

OVERHEAD = 1.2   # multiplier for context and buffers
EXTRA = 0.6      # GB of headroom

def _need(size):
    return size * OVERHEAD + EXTRA

def rate(model, hw):
    need = _need(model["size"])
    vram, ram = hw["vram_gb"], hw["ram_gb"]
    if vram and need <= vram * 0.95:
        return "gpu"        # fully in VRAM, fast
    if need <= ram * 0.7:
        return "mixed" if vram else "cpu"
    return "no"             # does not fit

The recommendation is the largest suitable "main" model (Qwen3 or Gemma 3) that fits in VRAM. With no discrete GPU it is a light model of at most 5 GB, because bigger dense models are too slow on a CPU. The picker only lists models that fit the PC by memory and by disk.

Installing Ollama

The installer is about 1.6 GB, so the download resumes: it lives in %TEMP%\LocalAI as a .part file and continues with a Range header:

done = os.path.getsize(part) if os.path.exists(part) else 0
headers = dict(UA, **({"Range": f"bytes={done}-"} if done else {}))
resp = urllib.request.urlopen(urllib.request.Request(SETUP_URL, headers=headers), timeout=30)
if resp.status != 206:   # server ignored Range, start over
    done = 0

Before running it, the Authenticode signature is checked (status Valid, signer O=Ollama), otherwise the file is deleted. The install is silent (/VERYSILENT /NORESTART /SUPPRESSMSGBOXES, /DIR="…" for a custom folder) and goes into the user profile, so no administrator rights. Then /api/pull downloads the model with progress; its read timeout is long because Ollama goes quiet while verifying sha256.

Things that went wrong

Ollama's own window on top of ours. The installer launches ollama app.exe, which opens a window over the app. Local AI finds it and sends WM_CLOSE: the app goes to the tray and the engine keeps running.

Black console windows. ollama serve must be started with CREATE_NO_WINDOW and without DETACHED_PROCESS. A process with no console makes every child (ollama.exe, the llama-server.exe runner) open its own black console. I checked with a window watcher (EnumWindows every 10 ms): after the fix there are no new windows except "Local AI".

Slow port check. On Windows a plain connect to a closed 127.0.0.1:11434 fails only after a couple of seconds because of SYN retries, which made /api/state take 3-5 seconds. Now a quick socket.create_connection with a 0.3 s timeout goes first, and the HTTP request only if the port is open.

The first reply looks instant. Ollama is stopped on exit, so the first answer waits for the model to load into memory (about 3 seconds on an RTX 3070). It looked like the whole answer appeared at once. Now the server sends {"status":"loading"} first if the model is not in /api/ps, and the bubble shows "Loading the model into memory…".

Moving models. The folder is set with OLLAMA_MODELS in HKCU\Environment plus a WM_SETTINGCHANGE broadcast. In Ollama 0.40 models live not only in blobs and manifests but also in manifests-v2 and metadata; move all of them or the model is invisible in the new folder. On the same drive it is a rename, otherwise a copy with progress; cancel or an error rolls everything back.

An uninstall that deletes itself. Ollama's uninstaller wipes ~/.ollama/models, so the models folder is renamed for the duration and put back. The Inno uninstaller re-launches itself from %TEMP% and returns immediately, so the app waits for ollama.exe to disappear and for the registry entry to go. The app's own exe is removed by a hidden PowerShell that waits for our processes (the PyInstaller onefile loader and its child), then deletes the exe, %APPDATA%\LocalAI, the unpacked _MEI* folder and finally itself.

localStorage and the port. Chats live in localStorage, which is tied to the origin including the port, and pywebview opens windows in private mode by default. So the window starts with private_mode=False and its own storage folder, and the server port is fixed (28765); if it is taken, any free port is used, but that run has its own chats.

No requestAnimationFrame while streaming. In a covered or hidden window frames freeze and the answer would arrive all at once, so the bubble is redrawn on a timer and only its innerHTML changes.

What I tested, and what I did not

On an RTX 3070 (8 GB) with 32 GB of RAM: a real install of Ollama 0.40.13 (silent install in about a minute), qwen3:8b in chat with and without think, about 236 tokens/s on gemma3:1b, moving models back and forth on one drive, and closing the window shutting Ollama down. The uninstall was tested in demo mode and on a copy of the exe with substituted APPDATA and TEMP; I did not run the real Ollama uninstaller. Not tested live: the system folder picker and reinstalling Ollama to another folder (demo only), and a real Ollama update. For UI work there is a demo mode: LOCALAI_DEMO=1 and python app/dev.py.

Limits and download

Windows 10/11 only. Ollama has no image or video generation, so those capability icons are always grey. The app is not code-signed, so SmartScreen may warn ("More info" → "Run anyway"), and some antivirus tools dislike PyInstaller executables; the source is open, so you can build it yourself.

• Download (about 43 MB): https://github.com/OlegChe77/local-ai/releases/latest/download/LocalAI.zip
• Source and README (MIT): https://github.com/OlegChe77/local-ai

If your approach to picking models differs, or Ollama behaves differently on your setup, tell me in the comments or in Issues.

What I wanted

• Notes are .md files in any folder; the app hides nothing in a database.
• [[Name]], [[Name#Section]], [[Name|label]], backlinks, #project/site tags, search across all notes.
• Live preview in the editor: the line with the caret shows raw Markdown, other lines show formatted text.
• Export to HTML and PDF.
• A folder with an exe that runs on a clean Windows 10/11 without installation.

How it is built

Storage. Vault reads every .md in the chosen folder (skipping hidden .folders), builds a link index and watches the folder for changes. Writes go through a temporary file, so a crash in the middle of a save never leaves half a note. When a note is renamed or moved, Vault.Move rewrites the [[links]] in all other notes, keeping #section and |label. The note object stays the same, so open tabs and history are not broken.

Editor. The base is AvaloniaEdit, a port of AvalonEdit. The live preview is not a replaced document but styling over the source text: element generators and transformers hide the markup and colour the pieces on every line except the one with the caret. The document is always the original Markdown, so undo, search and selection behave like in a normal editor.

Everything else follows from that:

• a table is one editor line turned into one element with cells, with the grid drawn by a separate renderer; the line with the caret shows the source, and its | are aligned to the grid lines (a second pass on VisualLinesChanged);
• a list marker with its indent becomes one element, the level comes from the indent, numbering stays text; - [ ] and - [x] show as checkboxes, a click changes one character and creates its own undo step;
• an image ![](assets/x.png) gets a row after the line, decoded in the background straight to the needed width;
• an embed ![[Name]] is a card with another note's content, nesting up to four levels, with circular embeds detected.

Why Avalonia and not a WebView

A WebView or Electron would have given me a Markdown renderer in an evening. With it comes a second heavy process, a noticeable start delay and questions about updating the runtime. I wanted one small native process. Avalonia 12 on .NET 8 draws through Skia, runs on Windows 10/11 and keeps everything in a single process. A side benefit: PDF is built without a browser too (below).

The price: the UI had to be written in code. The SDK installed on my machine (8.0.403) is older than Roslyn 4.14, so XAML would not compile (error CS9057), and the whole UI is C#.

Measured on a 5,013-line note (216k characters), 1200×780 window with panels, ReadyToRun build:

• 0.66–0.89 s to the first frame;
• about 133 MB working set after loading;
• 0.4 ms on average to handle a typed character (input + layout);
• 3 ms on average for Enter.

These are my measurements on one machine, a rough guide and not a benchmark.

Pitfalls

A window without a white strip. I wanted my own title bar with tabs and window buttons. With full decorations Avalonia 12 draws its own title over the tabs, and without extending the client area Windows 10 shows a 7-pixel white strip on top. What works:

WindowDecorations = WindowDecorations.BorderOnly;
ExtendClientAreaToDecorationsHint = true;

The window buttons are custom; I checked dragging, double-click, edges and corners, maximizing exactly to the work area, minimizing and closing.

Editor.Focus() does nothing. TextEditor does not take focus itself: the method returns false and focus ends up nowhere. Focus goes through Editor.TextArea.Focus(). A related detail: before hiding a panel that holds focus, move focus to the editor first and only then set IsVisible = false.

A collapsed table line. The |---| separator is hidden so that the line does not end up below the font (CollapseLines). But the collapsed line must be covered by the previous line's element (the header stretches to the end of the separator), otherwise AvaloniaEdit crashes. You only find that out by experiment.

The caret next to an image. Without a zero-width marker at the end of the line, the caret is drawn full-height on the image row. I added such a marker and handled the arrow keys separately: down goes to the next line, up or a click goes to the end of the text, so the caret never sits in the image row.

Typing speed. The block map (text, code, table rows) is rebuilt only when `, | or a line break is typed or deleted, and for - and : only if the line contains |. Scanning doc.Text as a string turned out several times cheaper than walking doc.Lines with GetCharAt: about 1.2 ms per Enter on 5,000 lines.

PDF without a browser. Export uses SKDocument.CreatePdf from SkiaSharp, which Avalonia already ships, so no WebView is needed. The layout is my own: A4, the selected theme's colours, word wrap, page numbers, links as annotations. But SkiaSharp is built without a font subsetter and embeds fonts whole: one page weighed 1.6 MB. I wrote my own FontSubset: glyph ids stay the same, unneeded outlines become empty, a new cmap is built and the GSUB and GPOS tables are dropped. A page went down to about 130 KB. CFF (OTTO) fonts are not subsetted.

Data over looks. The app sits in a folder with my real notes, so reliability took work:

• the file is changed outside while the app has unsaved edits: the tab gets a "conflict" state with a bar of choices ("Keep mine", "Take from disk", "Save mine as a copy", "Compare"); before writing, the file date is checked against the one the app saw, so a foreign edit is not overwritten even if the watcher was late;
• drafts are written in the background 1.5 s after an edit and removed on save; after a real crash the app offers to restore them;
• version snapshots with line diffs (Myers algorithm), limited to 50 per note and 100 MB in total; restoring a version is done as an edit, so Ctrl+Z undoes it too;
• a note renamed in Explorer: if one disappears and another with the same text appears in the same batch, it is treated as a rename and the tab follows the file.

To test a crash, the self-check starts a second instance of the app, edits without autosave, waits for the draft to appear and kills the process with Process.Kill(). Then the parent checks the file and the recovery.

One instance. A mutex named Local\Leaflet.Mutex.<data folder hash> plus a named pipe: a second launch passes its paths to the first and waits for "ok", and the first window comes to the front. The data folder hash is in the name so a portable copy, a regular one and the tests do not interfere.

Window position on several monitors. Sizes are stored in logical units, the position in pixels, plus the monitor scale. On start, the monitor list (EnumDisplayMonitors and GetDpiForMonitor) helps pick the monitor the window overlaps most, move the window inside the work area and make sure the title strip is at least 100 pixels. A window closed while maximized is a separate case: Avalonia then reports the monitor bounds, not the normal ones.

Windows scaling. The scale on my machine never changed, so the self-check sends the window a real WM_DPICHANGED and verifies that Avalonia recalculated the scale, the logical window size was kept, and panel edges stayed on whole pixels. Moving a window between monitors with different scales on real hardware is not something I tested; that is an honest limitation.

Build and shipping

The main zip is self-contained and runs on a clean Windows without .NET. The folder is 115 MB and the zip about 50 MB, against 44 and 18 MB for the variant that needs the .NET 8 Runtime installed. Start and memory are the same, so I chose convenience.

dotnet publish src/Leaflet -c Release -r win-x64 --self-contained true -p:PublishReadyToRun=true

I did not do single-file or trimming: Avalonia and AvaloniaEdit use reflection, and the size gain is not worth the risk. *.pdb files are removed from the package (SkiaSharp and HarfBuzz ones weigh about 100 MB). At the end build.ps1 unzips the package into a clean temp folder, starts the exe with a separate data folder and waits for the window to appear.

The app is not code-signed, so SmartScreen may show the blue window: "More info" → "Run anyway".

The result

Three themes (Graphite, Terminal, Light), English and Russian interface, remappable shortcuts, a command palette and built-in help.

The project is covered by its own self-check with 384 checks. It starts a real window and sends real key presses and mouse input (Ctrl+F, typing [[, dragging files, Ctrl+V with an image on the clipboard), so for a few minutes it takes over the keyboard and mouse and runs only on a copy of a test folder.

What it does not have: plugins, sync, mobile apps. It is a "folder of files" notes app, and anything else you can build on top with Git or a cloud folder.

Links

• Project page and source (MIT): https://github.com/OlegChe77/leaflet
• Ready zip (about 50 MB, Windows 10/11, nothing to install): https://github.com/OlegChe77/leaflet/releases/latest/download/Leaflet.zip

It is free. Suggestions and bug reports are welcome in the comments or in GitHub Issues.

This post is about the parts that were more interesting than I expected: how an app that must work for non-developers sets itself up, how it talks to the browser without exposing a hole in your machine, and how it updates itself without breaking.

The shape of the app

• a Flask server that listens on 127.0.0.1 only;
• a plain web page as the UI (no Electron: the browser you already have is the window);
• yt-dlp for extraction, ffmpeg for merging video and audio, Deno so yt-dlp can solve YouTube's JavaScript challenges;
• a small launcher with a tray icon, a browser extension and a bookmarklet.

The nice part of this design: the app is tiny, the UI is just HTML and JS, and there is no packaging step that fights antivirus software. The price is that a local web server is a bigger attack surface than people think.

Setup without installing anything

I did not want users to install Python, so the first launch bootstraps a private copy into the app folder: Python 3.12 (embeddable), pip, yt-dlp, ffmpeg and Deno. Nothing goes into the system or the registry, and deleting the folder removes everything.

Downloading executables from the internet at first start is exactly what you should be suspicious about, so every download is checked before it is used:

• each file has a pinned SHA-256, and if the hash does not match, the file is rejected;
• python.exe is additionally checked for the Python Software Foundation's digital signature.

The PowerShell helper that does the hash check is short:

function Get-Verified($url, $file, $sha256) {
    # a download whose hash does not match is never used
    Invoke-WebRequest -UseBasicParsing -Uri $url -OutFile $file
    $hash = (Get-FileHash -Algorithm SHA256 $file).Hash
    if ($hash -ne $sha256) { throw "hash mismatch for $(Split-Path $file -Leaf), not using it" }
}

The signature check on python.exe and python312.dll uses Get-AuthenticodeSignature and requires a valid signature from the Python Software Foundation. The new python folder is built next to the old one and renamed at the end, so an interrupted setup never leaves a half-installed copy.

A localhost server is not automatically private

Listening on 127.0.0.1 stops other machines from connecting. It does not stop other web pages in your browser from talking to it. Any site you open can send requests to http://127.0.0.1:PORT using your browser as the middleman, and a malicious site can even point its own domain at 127.0.0.1 (DNS rebinding) so the request looks same-origin.

My before_request guard handles both, and I would suggest it for any local web UI:

LOCAL_HOSTS = {f'127.0.0.1:{PORT}', f'localhost:{PORT}'}
LOCAL_ORIGINS = {f'http://{h}' for h in LOCAL_HOSTS}

@app.before_request
def only_own_page():
    # A foreign Host header means DNS rebinding: refuse.
    if request.host.lower() not in LOCAL_HOSTS:
        return Response('Forbidden', 403, mimetype='text/plain')
    if not request.path.startswith('/api/'):
        return None
    # The API answers only to its own page.
    origin = request.headers.get('Origin')
    if (origin and origin not in LOCAL_ORIGINS) or \
            request.headers.get('Sec-Fetch-Site') in ('cross-site', 'same-site'):
        return jsonify(error='Request from another page.'), 403
    # POST accepts JSON only: a plain HTML form from another site cannot send it.
    if request.method == 'POST' and not request.is_json:
        return jsonify(error='JSON required.'), 415
    return None

On top of that, responses carry X-Frame-Options: SAMEORIGIN (no clickjacking), Referrer-Policy: no-referrer, and Cross-Origin-Resource-Policy: same-origin for the API. Requests without Origin or Sec-Fetch-* (curl, tests, the "is it already running?" check) are allowed through.

Keeping up with sites that keep changing

yt-dlp breaks regularly because sites change, and a downloader that is a month old is a broken downloader. So the app:

1. updates yt-dlp by itself once a day;
2. checks GitHub for its own new version every three days, verifies the SHA-256 published with the release asset, and installs it with one click;
3. rolls back if the new version does not come up. A separate updater process waits for the app to exit, swaps the files, launches the new version and polls its local /api/status for the expected version number. If nothing answers in time, it restores the old files and writes the outcome to a result file.

Errors from yt-dlp are translated into plain language, with a "Details" button that shows the raw output for bug reports.

Proxies and the "site does not open" problem

A VPN browser extension does not help a separate program. So the app can discover a local proxy: it probes the default ports of VPN clients such as v2rayN, Hiddify and Clash, and accepts a proxy only if YouTube actually opens through it. The proxy is used when a site is unreachable directly, and the app remembers which sites needed it. A "secure DNS" switch handles the case where the provider simply does not resolve the domain.

Rough edges

• It ships as a zip with a .bat launcher, not as an installer.
• The browser extension is installed manually through "developer mode"; the Help page has step-by-step instructions with pictures.

Try it, read it, break it

• Download: universal-downloader.zip (Windows 10/11)
• Source: github.com/OlegChe77/universal-downloader

It is a wrapper meant for personal use, so download only what you have the right to and follow the terms of each site. If you find a hole in the localhost guard above, I would genuinely like to hear about it: open an issue.