I've been working on CityVisualizer, because apparently my response to a complicated process is “this needs buildings and tiny people.”

It’s a skill that turns descriptions of services, workflows and technical systems into interactive isometric maps. You can follow animated journeys, click into locations and explore what happens inside them.

Now you can watch the handoffs and see where things get stuck. I think this breaks down ideas and complicated stuff and makes it appear a lot easier. It supports cities, parks, buildings and technical systems. You can also prompt it to increase the things it supports. The output is a standalone HTML file that works offline, so you can share it without accidentally acquiring a hosting side quest.

Credit where it’s due: it builds on the MIT-licensed geometry core from Ryan’s Anatomy skill, with my own map layouts, visual styles and interactive storytelling around it. It’s also inspired by Bo Meyer’s work in visual modelling.

GitHub repo, examples and setup instructions

I used Claude to help write the skill instructions and map code, then worked through example maps with it to refine the visuals and interactions. I steered what each map should explain; Claude helped turn that into something clickable. There was a fair amount of “yes, but can we make what’s happening here actually understandable?”

Curious what people would use this for and whether it makes a messy process easier to understand, or just gives the mess better urban planning. Hope you find it interesting!

I haven't switched to Mac yet because of the crazy exchange rate, and also a lot of my work needs Windows. I really like SwiftUI, but I don't know enough of it to warrant buying a MacBook at this time, since React Native gets the job done - this is how I got the stupid idea of building a lightweight code editor and interpreter for Swift and SwiftUI.

Somewhat AI-assisted, to be honest, I don't have months to invest in this, but it's actually pretty decent, and I was able to build out a pretty complicated UI, all from my browser!

https://github.com/kevincoder-co-za/switaculous

Fully open-sourced and MIT-licensed.

Localix is an open source ADE (Agentic Development Environment): a workspace where you and agents share conversations, an editor, terminals, previews, databases, and a project board. Assign participants their own roles and models, attach visible context, and control agent tool access through capability rules. Bundled and custom plugins add workbenches and tools to the same app

Most planners are good at tomorrow. The moment you finish a task, it disappears. Personal Planner keeps the past.

- Hour-by-hour Day view with timers (planned vs actual)

- Daily, weekly and overview reviews

- Year-long consistency heatmap with streaks

- Experiments: tag your blocks, set a window and targets, and it tracks a new habit from the work you already log

- Inbox that turns ideas into dated, timed tasks

- Local-first, works offline, optional Supabase sync

Flutter, Drift + SQLite, Riverpod, Supabase, Cloudflare Workers. Linux, Android, Windows and macOS. Free, no paywall. Windows and macOS builds are unsigned, and macOS is only tested on GitHub Actions.

Code: https://github.com/Karthikshabari/PersonalPlanner

Releases: https://github.com/Karthikshabari/PersonalPlanner/releases

What would you add as addtional feature here?

f your Go debugging loop is: send the request in Postman, switch to the IDE, hope the breakpoint hits, open pprof in a third window, tail logs in a fourth — adOmnia puts that loop in one app.

Recognized HTTP routes link to their handlers. "Debug Request" attaches Delve, pauses in the handler, and shows frames, variables and goroutines next to the API response. With capture on, the SQL and Kafka messages the request produced come along for the ride.

Go side: gopls, test explorer + coverage, Delve (conditional breakpoints, goroutine inspection), pprof, execution traces, architecture/impact views. Around it: an API client (REST/gRPC/SOAP/WebSocket), database tools (Postgres/MySQL/Mongo/Redis/SQLite), broker and log viewers.

Local-first, no account, no telemetry, MIT, built with Go + Wails. Runs on Windows/macOS/Linux.

Releases: https://github.com/Andrea-Cavallo/adOmnia/releases/latest

I made Danfeed for my own use for when i want to search a drawing inspiration, i build it with TikTok design in mind, give me any suggestion!

try it: https://danfeed.porterfrag.workers.dev/

github repo: https://github.com/Porterfrag/danfeed

I'm building my own programming language and compiler: Raz.

It translates Raz code into C++, with the goal of turning .raz programs into native executables. The project is a work in progress, and I'd love to hear your feedback.

https://github.com/marboris/razlang

I'm building my own programming language and compiler: Raz.

It translates Raz code into C++, with the goal of turning .raz programs into native executables. The project is a work in progress, and I'd love to hear your feedback.

https://github.com/marboris/razlang

SurfSense is an Apache-2.0 desktop app for Windows, macOS (Apple Silicon) and Linux, for documents you can't upload. It's like NotebookLM, but it runs on your machine and works with any model: a local one it downloads for you, any OpenAI-compatible API, or your ChatGPT Plus or Pro plan. There's no account and no telemetry, and remote hosts stay off until you allow them.

What it does:

• Q&A with cited answers from your PDFs, Office files, CSV, Markdown, HTML and images. OCR reads scanned pages.
• An agent that writes Word documents, PDFs, slides and spreadsheets, or starts from your own .docx or .pptx as a template.
• Edits your files as a new copy. Word edits come back as tracked changes. It updates Excel formulas, fills PDF forms, and merges or splits PDFs.
• Mind maps, flashcards, quizzes and podcasts, like NotebookLM's Studio.
• MCP plugins. Connect servers from the plugin registry, such as DeepWiki, or any MCP server by URL. They stay off until you allow them.

Stack: Electron with React and Vite, a FastAPI backend, Docling for parsing and OCR, llama.cpp for local models, and opencode as the agent engine.

Where it's weaker: no video overviews and sources are files only, so no YouTube or web links.

Feedback and issues are welcome: https://github.com/MODSetter/SurfSense

I’m collecting language models running locally on unusual hardware. The list includes retro computers, game consoles and microcontrollers.

A few examples:

• Commodore 64 with a 2 MB RAM expansion, running a tiny 260K parameter story model.
• A 66 MHz 486 running that same model under DOS.
• Nintendo Wii running a 15M parameter model with int8 weights.
• Ports for PSP, ESP32 and Raspberry Pi Pico boards.

Each entry includes hardware requirements, the model checkpoint, reported speed where available, and links to the original project or writeup. Emulator demos and remote clients have separate sections.

I maintain the collection. All credit for making these ports work goes to their original authors.

https://github.com/emrehangorgec/awesome-llm-on-anything

Know another documented port that belongs here? I’d appreciate a link. Corrections to the existing entries are welcome too.

Hello all,

I’ve built a music aware desktop turntable for Linux, with everything designed in Blender.

The record spins with your music, the tonearm follows the track’s progress, and album artwork appears on the sleeve and record. You can control playback and volume directly from the turntable.

It follows your music player rather than playing music itself, including compatible browsers too. Available controls and artwork depend on what the player provides through MPRIS.

Regarding Performance, Talis reuses the static background and updates only the parts that change. Continuous redraws stop when there’s nothing animating, and “Pause when hidden” reduces rendering work if the DE supports it. Scenes are rendered in blender upto 4K.

I am working of few more features and additions too.

Get it here: Github or buymeacoffee (If you wanna support)

Thank you ;)

Hey everyone!

For the past 6 months, I've been building Trigora, a high-performance durable execution platform for long-running AI agents and programs.

It's powered by Transparent Continuation Checkpointing (TCC), an execution architecture I've been developing to eliminate history replay during recovery.

It started with a simple question: Why should a program have to repeat work it's already done just to recover from a crash?

Many existing systems recover by replaying what happened before the failure. That works, but it can become increasingly expensive as programs run longer.

I wanted to take a different approach. Instead of replaying the past, TCC saves the information needed to pick up where the program left off. If something crashes, a fresh worker can restore that saved state and continue without replaying the execution history.

Some highlights:

• ⚡ Ultra-fast recovery: I've measured recovery as fast as 0.06 ms at the engine level.
• 🔄 No history replay: Recovery restores committed state directly.
• 🦀 Rust/WASM engine: The core is written in Rust, with native and WebAssembly support.
• 🛠️ Built-in developer tooling: Benchmark execution, verify durability, and simulate failures with fault injection.
• 💻 Multiple languages: TypeScript, Python, and Rust SDKs, with more languages planned.
• ☁️ Cloud + local development: CLI, local runtime, and managed Cloud platform.

It's designed for programs that need to survive failures, wait for external events, run AI agents, or execute for hours or days.

I've recently launched the platform, and I'm now trying to get it into the hands of developers who might actually find it useful.

There's also a technical report covering the architecture, benchmarks, and limitations if anyone wants to dig deeper.

I'd genuinely appreciate feedback, particularly from anyone who's worked with durable workflows, background jobs, or AI agents.

GitHub: https://github.com/trigora-dev/trigora

Website: https://trigora.dev

Would you find something like this useful in your projects? And what would make you hesitant to adopt it?

Hi everybody,

I've been working on Aurai, a self hosted web app for enhancing, colorizing, repairing old and new photos, as well as editing and animating videos using AI models through OpenRouter.

I had some old photos that I wanted to enhance the coloring, repair them but I couldn't find a free tool that uses AI models, and came up empty on Github. There are great but expensive tools but I wanted more control as well as wanted to experiment on the models out there.

So I decided to build my own. I used Openrouter to test with different image and video models, compare them and find the best results without being locked into one model or editing workflow.

You can use it to:

• Restore faded and yellowed old photos
• Colorize black-and-white pictures
• Repair scratches and upscale images
• Edit photos using natural-language prompts
• Animate still photos and transform videos
• Compare different AI models for the same task

Basically it asks AI what to enhance, AI model gives you the regions and color enhancements for local editing (so you can ensure the photo stays the same), as well as gives you a full AI edited image. You can compare local edits vs AI edits and get the best fit based on your needs.

Aurai runs with Docker, and you bring your own OpenRouter account. It's open source under the MIT license, and contributions/PR are welcome.

GitHub: https://github.com/meceware/aurai

It's vibe coded btw, and this is my first vibe coded project, I developed it as a side experiment and burned my many beautiful tokens 😂

For reference, in my own testing, image edits have typically cost around $0.10–$0.20 per image, while video edits have cost around $0.50–$1 for videos around 5–10 seconds long. Actual costs depend on the models and settings.

I’ve been using physical pocket calculators since the mid-1980s, and I’ve always loved the speed, tactile feedback, and direct control of hardware key layouts. The main motivation behind ViCalc was to bring that exact same speed and workflow efficiency to a modern PC keyboard—allowing you to touch-type mathematics seamlessly without taking your hands off the keys to click UI buttons.

Rather than just imitating a physical handheld calculator, ViCalc is built to optimize desktop mathematical workflows and complex calculation tracking.

🧮 Key Features & Workflow Design

• Direct Keyboard Mapping: All functions and operations are directly mapped to your PC keyboard, eliminating the need to click through UI buttons with a mouse (though mouse/touch interaction is fully supported if preferred!).
• Full & Exportable Calculation History: The entire step-by-step history is logged automatically as you work. This makes it effortless to review your process or copy-paste the entire multi-step calculation directly into research notes, LaTeX documents, or technical reports.
• Flexible & Adaptable GUI:
  • Minimalist View: Hide virtual keys entirely—ideal once you learn the shortcut mappings by heart.
  • Custom Views: Toggle between a standard numpad, a compact left-side layout, or a full scientific keyboard layout.
  • Expandable History Pane: Easily track, review, and manage long sequence calculations.

🛠️ Modes & Technical Details

• Scientific & Complex Modes: Full suite of trigonometric, scientific functions, and complex arithmetic support.
• Programmer Mode (Base-N): Bitwise operations and conversions across Hex, Dec, Oct, and Bin.
• Language: Python 3
• License: Open Source (MIT License)

🔗 Links & Downloads

• GitHub Repository: github.com/Kudaschov/ViCalc
• Windows Installer: ViCalcSetup.exe
• Homepage: kudaschov.de/en/vicalc-4

I’d love to hear your thoughts, feedback, or any feature requests from the community! How do you currently handle rapid calculations and history logging on desktop?

Hi everyone,

I started working on this project out of pure frustration with how we connect software today. We often hear that systems are "integrated," but in practice, it’s mostly superficial—endless boilerplate code, messy spaghetti architectures, and rigid connections. Even AI agents or cross-platform services struggle behind the scenes because the underlying infrastructure wasn't designed for seamless interaction.

Instead of writing custom glue code over and over, I tried stepping back to build a lightweight, config-driven core (WOS) that acts as an adapter layer. The goal is to let services and software talk through a single unified protocol without hardcoding.

I've opened the source code and documentation on GitHub because I believe fundamental architecture grows best when refined by the community:

Repository & Architecture Docs: https://github.com/Auto55597/wos

Since I'm building this from my own perspective, I'd really love to validate my assumptions with experienced system engineers here:

1. Is this integration friction something you actually deal with in production, or am I overcomplicating a solved problem?
2. Looking at this core concept, where do you see potential bottlenecks or flaws in the architecture?

Thanks for any feedback or critiques!

sqlleaf is a tool to help you to understand how your data flows across your systems by producing detailed, column-level lineage across any SQL query and dialect.

It extends beyond traditional lineage tools by mapping relationships across all kinds of expressions, such as columns, functions, literals and variables.

It addition, it can process many kinds of statements (insert, update, merge, copy, unload, execute, perform, put, and many more), as well as all kinds of objects (tables, views, procedures, types, UDFs, stages, sequences, etc).

It even has a PL/pgSQL parser, allowing you to generate lineage for dynamic, procedural SQL in Postgres.

sqlleaf builds on top of sqlglot, the popular SQL transpiler, and so it inherits support for all of its dialects (30+). However, there are still many dialect-specific features that need to be implemented, as the list of features for each dialect is extremely long.

I hope some of you find this project useful. It still has a long way to go. My vision is to see it become a library, or even a layer, in the data engineering stack that opens up a range of new applications that can be created, such as SQL validators, impact analysis, and tracing/auditing systems.

URL: https://github.com/sqlleaf-io/sqlleaf

Contributions and feedback are most welcome!

P.S. why I made this: I recently had to trace and delete sensitive data across an enterprise's large data warehouse, but the tooling that existed (both open source and proprietary) had limitations that prevented my team from doing so. After months of experimentation, I eventually realized that I had no choice but to roll my own.

A few months ago I shared Screencap here, and now I'm super happy to announce that version 2.0 is a full rewrite in Swift:)

It runs in the background on under 1% of one CPU core and about 30 MB of memory, smartly takes a screenshot when your screen settles, reads it with on-device OCR, and categorizes it with ZDR System-One decision models to help you (and your agents via MCP!) to better understand past activities. And it's also very easy to play with:

Download & check sources: https://github.com/yahorbarkouski/screencap

Happy to listen to any feedback, especially from users who tried it before

Start on your desktop, run onthego sync laptop, then claude --resume or codex resume on the laptop and keep the same conversation. Staged, unstaged and untracked changes come along. Your own SSH, no account, no server. macOS and Linux.