Big tech wants everyone to believe that real AI requires billion-dollar cloud datacenters and giant proprietary models. For the past six months, I worked to build the exact opposite: an open-source, local intelligence engine called Hillock that gives AI reliable long-term memory while running entirely on your own laptop CPU under 1.2GB of memory. Today I finally shipped the v1.0.0 stable milestone.

I got frustrated watching basic AI memory turn into a bloated commercial ecosystem where you have to send all your private data to cloud vector databases just to prevent a chatbot from forgetting what you said five minutes ago. Hillock combines a fast local SQLite knowledge graph with computational neuroscience principles like Hebbian synaptic learning and hyperdimensional computing. It learns factual associations on the fly, remembers co-occurring concepts without backpropagation, and uses mathematical gating so your AI never hallucinates on facts it does not know.

I built this project while finishing high school and preparing for my university studies in electronic systems design. I have been updating the community through pre-releases, and seeing v1.0 officially tagged and stable feels like an incredible milestone.

Hillock is dual-licensed with the open-source version under AGPL-3.0 because I strongly believe personal AI should be private, local, and owned by the user. If you believe in local software and want to support an independent young builder, please check out the repo and consider leaving a star to help put it on the map: https://github.com/roandejager/Hillock

A friend told me that every phone remote app he tried seemed to come with ads or payment prompts. I started making one for him, then got carried away making the controls customizable. I figured other people might want the same thing, so I opened the source.

OpenTV-Remote has native Android (Kotlin/Jetpack Compose) and iPhone (SwiftUI) apps. You can drag and resize buttons, choose presets and accent colors, save layouts for different TVs, and add app shortcuts where the TV supports them. No ads, subscriptions, paid unlocks, account requirement, or telemetry SDK. MIT licensed.

For anyone interested in the code: discovery/pairing and each TV protocol are separated from the UI, with explicit capabilities determining which controls are offered. Android TV keyboard sync uses transient IME sessions with readback/acknowledgments where available, plus a clearly labeled manual fallback.

This is a development release. Basic Android TV control has been used on a real MiTV; newer live keyboard behavior and other TV providers need broader hardware qualification. It is not universally compatible, Android TV Wi-Fi touchpad mode sends arrows rather than a mouse cursor, and casting is not included.

Android APKs are in Releases. The iPhone version currently requires a Mac and Xcode; it isn't on the App Store.

Disclosure: I'm the developer, and this was built with substantial AI assistance/vibe coding. The repository includes protocol notes, compatibility limits, and a record of what was actually tested.

Source: https://github.com/levhakobyan/OpenTV-Remote

Downloads and iPhone setup: https://levhakobyan.github.io/OpenTV-Remote/

The three screenshots show two Android layouts/colors and the iPhone app. Suggestions and bug reports are welcome.

Two weeks ago I released Prism, a free, open-source download manager for Windows, macOS and Linux (Rust + Tauri, MIT). It just passed 100 stars on GitHub, and since a good part of the feedback came from Reddit threads, I wanted to say thanks and show what it turned into.

**What changed since 1.0, mostly because someone reported it:**

- **8 languages:** Czech, German, Spanish, French, Italian, Indonesian and Arabic (the whole window mirrors right to left)

- **The browser extension is on the Chrome Web Store**, and Zen and Helium are supported

- **Linux:** the main window shows again on KDE Plasma, magnet and .torrent links open in Prism, Zen/Firefox with new profiles connect, the RPM works with RPM Fusion's ffmpeg

- **Lighter in the tray:** after a minute there, Prism closes its window to free the web view's memory

- **Sites with a robot check** are left to the browser instead of saving an error page as your file

- **.torrent links** open the *Add torrent* window instead of failing

- **Quality list for HLS/DASH streams**, from a community PR

- Compact view, playlist names and numbering, a portable version that finds the extension again, and security fixes in 1.0.8

**By the numbers:** 16 releases, 2,200+ downloads, 15 issues (11 closed), 8 pull requests from 3 contributors.

**Next (1.1.6, almost ready):** the light theme fully light on Windows, Brave Origin on Linux and macOS, VK videos, and a YouTube retry when signed-in cookies are rejected.

**Thank you, Reddit.** A lot of Prism's first two weeks happened in comment threads like this one. People installed a brand-new app from someone they'd never heard of, ran it on setups I don't have, and took the time to write down what broke. That's a big part of why there were 16 releases and not two.

Special thanks to u/CredibleWrong for finding the Brave Origin problem (fixed in 1.1.6), u/Nanobuo for asking about Helium (supported since 1.1.0) and u/StressLiving6734 for the video button ideas. And to everyone who left a bug report, an idea or just told me it works for them: thank you, all of it helped.

If you've tried it: what's still missing or annoying? Bug reports are what made most of these releases.

GitHub: https://github.com/FortoGraphy/prism-download-manager

Website: https://prismdl.site

Hi everyone,

I’d like to introduce a new Java desktop toolkit, built from the ground up.

It includes dozens of components, accessibility support across three operating systems (Windows, macOS, and Linux), advanced language support, text direction, video, music, 3D, and charts.

The appearance is fully customizable (including dark themes), animations are native, and all the features you’d expect are there: printing, desktop integration, and testability.

I hope the community enjoys it. Although it is—admittedly—the product of AI, it was crafted with great care over the course of several months, ultimately saving tokens for anyone looking to build desktop applications.

https://limn-toolkit.github.io/limn-toolkit/

Enjoy

I'm working on an idea called NeuroStudio: an open-source, self-hosted AI training studio that combines a beginner-friendly visual interface with the flexibility of established machine-learning frameworks.

The basic idea is to let users create datasets, train models, evaluate results, and run inference locally instead of relying on a cloud-based training platform.

I'm considering Go for the main application, SQLite for metadata, and interchangeable training backends such as PyTorch and TensorFlow where appropriate. ONNX Runtime would handle compatible inference workflows.

I don't want to reinvent every ML framework. I'd rather build a lightweight application that connects existing tools through a consistent interface.

Features I'm considering

• Visual dataset management and annotation
• Image classification and transfer learning
• Training progress, checkpoints, and evaluation metrics
• Webcam-based model testing
• Model export and local inference
• Additional audio, pose, and object-detection workflows
• An extension system for integrating other training engines

The biggest challenge is making the application easy to run locally without creating an enormous installation or pretending that every model can train on every computer.

I'm planning to start with one complete image-classification workflow and expand from there.

I'd appreciate technical feedback

1. Would you use Go as the main application backend with separate training workers, or choose Rust?
2. What is the cleanest interface for connecting different ML training frameworks?
3. Which features are missing from existing local AI development tools?
4. What would make this project meaningfully different from existing visual ML platforms?

I'm interested in honest criticism, architectural suggestions, and feature ideas.

If you have experience building ML tooling, I'd particularly appreciate your thoughts on the training-backend architecture.

I kept rebuilding Windows 10 install media by hand (DISM commands, hunting updates in the Update Catalog, fixing driver signatures), so I turned it into one tool.

**Win10 ISO Updater** is a single `.cmd` file with a GUI. Double-click it, pick your Windows 10 ISO, and it:

- downloads the latest updates from the Microsoft Update Catalog (cumulative update, servicing stack, Safe OS / Setup Dynamic Updates, .NET) and slipstreams them

- adds drivers exported from your PC (storage and network drivers also go into boot.wim and WinRE, so Setup sees NVMe/RAID disks)

- re-signs modded NVIDIA drivers (NVCleanstall hardware-ID mods) with your own certificate, so they install during setup with Secure Boot still on

- adds your autounattend.xml and $OEM$ folder

- runs an install check first (answer file mistakes, scripts that wait for a key press, drivers Windows will refuse), with one-click fixes

- builds a bootable BIOS + UEFI ISO

A few details:

- Nothing to install. The Microsoft tools it needs (oscdimg, Inf2Cat, signtool) are downloaded from Microsoft when a step needs them.

- No telemetry. It only connects to Microsoft servers.

- Speed: boot.wim and WinRE are updated in the background at the same time as install.wim, and the PC is kept awake during long jobs.

- Driver signing only re-catalogues the INF files you edited, with several runs at once, instead of all ~40 INFs in NVIDIA's Display.Driver (that used to take up to an hour).

- Updates stop at 2025-10, the last month Microsoft allows offline. ESU updates still come from Windows Update on enrolled PCs.

- You need your own Windows ISO and license. No keys and no activation tricks are included.

Screenshots and download (open source, MIT):

https://github.com/j0p3s/Win10-ISO-Updater

It's written in PowerShell 5.1 with a WPF interface, and the test suites run on Linux with PowerShell 7. Feedback and bug reports are very welcome, especially from people who try it on other builds (LTSC 2019 / 2021, x86, ARM64).

I have built with Claude a Home Control application that can manage TV's, Sky TV, Android TV, Hive Heating, Phillips Lights, and Ring door Bell. It also have routines built in as well.

Link to GitHub below

https://github.com/foleys1972/HomeControl

Video
https://youtu.be/ov6Ox4q7hdU

Hi! I built this because self-hosted Excalidraw only gives you the canvas: drawings stay in your browser, and there are no accounts or folders.

Excaliself adds:

• accounts with invite links, and a shared team space next to each person's private space
• folders, stars, and search that finds text inside drawings (⌘K)
• live collaboration with cursors and guest links
• everything stored in your own Postgres

One docker compose file (amd64 + arm64), MIT.

Repo: https://github.com/maciekzygmunt/excaliself Website: https://excaliself.com

Feedback is welcome, especially what is missing for your team.

I built a custom LLM-powered bot using Ollama and Python that acts like a strict, arrogant anime noblewoman. (Customizable persona)

Guys I know it's chinese and a bit of AI slop but you can definitely customize them into your language

I personally hate slash commands in discord cause it kinda ruins the vibe of chatbot so I made it with regex scanning your messages for strict command matching patterns

What makes it fun:

1. It remembers what you did. If your friends did something stupid and was caught, you can store them into the database with commands and the bot will remember it and possibly mock them when replying to them/messages mentioning them
2. Dynamic Affection. It has a hidden affection score (from -100 to 100). Rises and drops according to what you said and the persona of your bot -- it will affect how the bot replies to you, the bot also knows whether it is mentioned in the message, this will affect the reply of the bot and the affection score
3. Punishment System. If an admin mutes or bans someone, the bot instantly generates a dramatic, classical Chinese edict to announce the punishment.
4. It reads images. Send a screenshot without even mentioning it, and it might just jump in to criticize the picture

It's completely free to run (using Ollama's free cloud tier) and totally open-source

GitHub Link: https://github.com/Lynn-000/project-anima

(forgive me for the ai-assisted readme, it is way much faster..)

(below is the translation of the image)

[User xd]

-63-11 = -74 (context: the user xd once said -63-11 = -73 and was recorded)

[祥子 Sakiko]

(sneers) You still dare to do math in front of me?

-74? You think that just by changing the answer, your previous "black history" of -73 will disappear like an erased musical note? This level of "correction" not only proves your previous stupidity but also proves that you are still trying to save face using such a clumsy method.

Litang King? Someone who fails at basic arithmetic actually dares to hold such a title. Trash like you is simply the modern version of the Lingling General Xing Daorong* — full of empty boasts, with absolutely nothing in your brain.

Do you think it's fun wasting my time on such a completely obvious math problem? If you haven't realized how ridiculous you look right now, I suggest you shut up early, otherwise I really might not be able to resist poking ten thousand transparent holes in you.

[User xd]

yeah sybau

[祥子 Sakiko]

sybau? (sneers) After I exposed your stupidity, you can only use this crude abbreviation to cover up your embarrassment?

It seems your vocabulary is in the same state of desperate poverty as your math skills. Trying to use internet slang to maintain your so-called "cool" at a time like this is even more ridiculous than when you calculated -73.

Litang King? Wearing this title, but you can't even say a complete sentence, only sending out a few letters like an unweaned child. Your level of cognition is simply a desecration of the art of language.

Since you love abbreviations so much, I'll give you one too: GTFO. Now, immediately, get out of my sight.

Introducing Heimdall, a glassy launcher for Windows. And yes, it's faster than Everything.

Press the hotkey of your choice, and type. It finds apps, every file, open windows, calculates sums and web searches.

Native Rust, under 2 MB, ZERO telemetry. Free and open source.

EDIT: Thank you for the great reception! I just published the 1.0.3 release with some more QoL and fixes for a few annoying quirks. It's also faster than before, and now beats Everything on every search metric. It's also come to my attention that the link doesn't show up for some reason, so you can get it here:

github(.)com/Kryzern/Heimdall

I'm the author, so this is self-promo — the reason I wrote it is one specific annoyance: most Windows cleaners don't tell you what they are about to delete until it is gone, and some will happily follow a junction out of `%TEMP%` into your Documents folder.

**Swept** is a single portable `.exe` (Python + CustomTkinter, MIT). Five tabs: Clean, Install, Optimize, Schedule, Log.

**Cleanup — 22 categories.** Analyze only measures; nothing is deleted until you press Clean, and Clean itself has a scan-only switch. Every path that gets removed or skipped is written to the log.

**Install — 24 programs** from the vendors' own CDNs. No winget, no bundled downloader. Each file must carry a valid Authenticode signature from the expected publisher, or match a SHA-256 pinned in the catalog — 7-Zip and K-Lite ship genuinely unsigned installers, so they are hash-pinned rather than waved through.

**Optimize — 12 tweaks**, with a system restore point created before anything is applied. **Schedule** — daily or weekly cleanup, dry run first, optionally a Task Scheduler task that runs Swept headless.

The part I actually care about is the safety model:

- Whitelist of job-defined folders, hard blacklist of `System32`, `WinSxS`, `Fonts`, `servicing`, `Program Files`; `pagefile.sys`, `hiberfil.sys`, `ntuser.dat` and friends refused by name.

- Junctions and symlinks are skipped while scanning and refused while deleting — and the *resolved* path is checked against the whitelist too, so a junction cannot smuggle `Documents` in.

- No `PATH` lookups for `powercfg`, `tasklist`, `dism`: they resolve to `%SystemRoot%\System32`, so a planted executable cannot inherit elevation.

- Installers run as an argument vector with `shell=False`, from `%ProgramData%\SweptSecureTemp`, whose ACL allows only SYSTEM and Administrators.

Honest caveats: the `.exe` carries a self-signed certificate, so SmartScreen still reports an unknown publisher; some registry values get re-applied by Windows after a feature update (the app reports those as unavailable instead of pretending they worked); the program catalog is fixed on purpose, so it can never be pointed at an arbitrary URL.

Numbers from my own machine, if it helps calibrate: the scan finds 2.54 GB, of which 1.12 GB is caches people don't think about — GPU shader cache 789 MB, Discord 336 MB, thumbnails 18 MB.

Windows 10/11, English and Russian interface, no telemetry, no background services, no install required: https://github.com/vladcodex/swept

What I would like to know: which category is useless, what is missing, and where you would be afraid to press the button.

--------------------------------

I used Loom for years and liked it, but I got tired of the high prices, the features locked behind higher tiers, and having all my videos sit on someone else's servers. So I built an open-source version I could actually own.

CaptureFlow works the way you'd expect if you've used Loom. Record your screen with your camera in a bubble, and you get a link you can share with anyone. It uploads while you're still recording, so the link is ready right away.

What's there today:

• Record a tab, a window or your whole screen, with camera and mic
• Viewers can comment and react with emoji on the video, and you can see who watched
• Transcripts through Whisper
• Annotated screenshots, shared by link too
• Team workspaces with public, workspace-only or private videos

Where it's different:

• AGPL-3.0, with no "open core" split. Every feature is in the repo.
• Self-host it two ways. With Docker, docker compose up keeps everything in one folder (SQLite plus your videos as plain files). Or deploy it to your own Cloudflare account (Workers, D1 and R2) if you'd rather not run a server.
• The capture engine behind the Chrome extension and the Mac app is MIT, so you can reuse it in your own projects.

You record with the Chrome extension or the Mac app for now. Windows is next.

Website: https://captureflow.dev

Repo: https://github.com/sardorml/captureflow

Self-hosting guides: https://docs.captureflow.dev/self-hosting/docker (Docker) and https://docs.captureflow.dev/self-hosting/cloudflare (Cloudflare)

It's still early, so I'd love honest feedback, especially from people who use Loom every day. What would you miss if you switched? Issues and PRs are very welcome.

Wondering if anyone would be interested in a open source application I built for developing many projects with agents.

I had a small disaster a few weeks ago where a model deleted my home directory. I had to restrict the models, but constantly being asked to approve commands was slowing productivity.

I reached out for sandbox suggestions but didn't find anything which suited me.

There was also the problem that I could only develop one or two application simultaneously before I would run out of memory on my laptop. I turned to K3S, starting with a single node.

The application makes it easy to spin up containers specifically for developing applications, it provides access to each via SSH.

I can now work on any number of projects without straining the laptop. https://github.com/8perezm/esuyo-coding-container It can be used as electron app, a web gui or with the CLI, whatever you prefer.

https://github.com/8perezm/esuyo-coding-container

Hey everyone,

Wanted to share a project I wrapped up called Optimash: https:!! optimash.vercel.app

It's a deadpan corporate parody designed like a high-end automotive configurator (Aston Martin/Porsche style) for a humanoid home robot.

Technical Breakdown:

• 3D Engine: Three.js / React Three Fiber
• Asset Optimization: Draco GLTF compression to keep initial payload small and maintain 60fps on mobile GPUs
• Features: Real-time camera transitions between config nodes, dynamic paint/lighting swaps, client-side spec sheet generation

Happy to answer any questions about the R3F setup or optimization workflow!

Hello redditors,

I started learning python in my free time about 2 months ago and a few weeks ago made a simple program. you type and if a double tap happens, the program informs you about it.

It runs directly in your CMD, is extremely lightweight and does not store any information of any kind.

You can check it out right here: https://github.com/galcomez/keyboard_outputs, you have a simple .exe program and full source code, if you want to check it out!

I'm building Emend. It adds AI writing to a Tiptap editor: rewrite selected text, write new text, or ask questions about the document.

What you get:

• Three AI components (bubble menu, composer, document chat), or a full editor starter
• Already have a Tiptap editor? Just add the components to it
• Bring your own AI key and start using it
• The AI never changes text until the user accepts it

It's still early, so I'd love your feedback.

GitHub: https://github.com/amittam104/emend

A Commodore 64 with a RAM expansion. A DOS PC. A PSP. A Nintendo Wii. Even a smartwatch.

People have gotten language models running locally on all of them, so I started collecting the projects in Awesome LLM on Anything.

A few highlights:

• Commodore 64: roughly one token every 8 minutes, according to the author.
• New Nintendo 3DS: a 15M parameter story model reaching about 23 tokens/sec with Q4 weights.
• Pixel Watch 3: SmolLM2 running on the watch itself.

Some are tiny story generators; others run larger models. Each entry links to the original project or write-up, with the model and reported speed where available. Emulator-only ports and remote clients have separate sections.

I maintain the collection; credit for the ports belongs to their authors.

Browse the list on GitHub

Know an even stranger device running a language model? Send me a link. And if you enjoy this particular rabbit hole, a GitHub star is appreciated.

Small side project to upgrade y'all README.md's: https://github.com/PaulGoldschmidt/lines-of-code-history with https://loc-history.com

enjoy!

Meet Mnemo: a terminal coding agent that actually remembers.

🐘 Persistent memory across sessions

🧠 Sub-agents you can talk to + a shared task board

🔌 Code index, MCP, hooks, schedules

Open source, runs in your terminal.

https://mnemo.atmanmishra.dev

https://github.com/AtmanMishra/Mnemo

#AI #CodingAgent #OpenSource

The goal: Arc-style spaces in one window, but with real isolation. Each space gets its own cookies, storage, history, passwords, form data, extensions, permissions and downloads. Firefox containers only cover cookies and storage, and profiles need separate windows, so this needed a different approach.

How it’s put together:

• app/: Swell is its own Gecko application, built inside a Firefox source checkout the same way Thunderbird’s comm/ is. It has its own window document, not a restyled Firefox UI.
• core/: a Rust core owns the app state: the sidebar tree, spaces, and per-space data.
• patches/: a small patch queue for the engine changes that can’t live outside Gecko, applied on top of a pinned Firefox revision (FIREFOX_REV).
• Extensions per space: each space gets its own copy of an extension, scoped so it only sees that space’s tabs.
• Passwords: stored per space, encrypted with a per-space key in the OS keychain.
• Tests: an isolation suite checks 17 state stores for cross-space leaks. There are also Rust unit tests, xpcshell and browser tests, and an end-to-end restart test.

It’s an alpha: Apple Silicon macOS and x86 Linux, unsigned builds, no telemetry, MPL 2.0. Build from source takes about 30 minutes and 15–20 GB.

Feedback on the architecture and the isolation model is very welcome, and so are contributors. CONTRIBUTING.md explains the setup.

Github: https://github.com/ivantacca/swell
Website: https://ivantacca.github.io/swell/