Show HN: Lific: Issue trackers should be simple, right? https://ift.tt/vXMV3gp

Show HN: Lific: Issue trackers should be simple, right? I built Lific because I direct AI coding agents on largish projects and needed somewhere for project state to live that isn't markdown files in the repo. When I was begging to work on long horizon ideas, I started on Linear, but my agent files issues faster than a human does, and I hit their limits and pricing wall almost immediately. Then I self-hosted a popular open source tracker which meant running its 13 containers, and its MCP integration was 30k tokens and I got so fed up that I eventually removed it and went back to .md files for a few weeks. Lific is the opposite shape of most of your self hosted server issue trackers: It's a single Rust binary that uses SQLite, and it has an optimized MCP server built in. Web UI is also included integrated directly into the binary. The simplicity is meant to only apply to the size and the ease of installation. The web UI is fully fleshed out with all of the UX you would expect from an issue tracker like linear. Since I started using lific, my agent flow is that I open the web UI, find a few issues I want to work on, then tell the agent "work on LIF-298, 299 and 301, and if you find bugs, file them as new issues." At the end of the day the project has tracked itself. Issues have statuses, blockers, and comment threads, so "what's workable right now" is a query instead of the agent guessing. Plans are persisted step trees, so a session tomorrow resumes with the same understanding of the goal and the path as the session that made the plan. My largest project has 300+ issues and 100+ docs and agents search it fast. Everything exports to markdown in one click, and the database is just a file on your machine. Setup is ` cargo install ` ` lific init ` ` lific connect ` then pick your harness (OpenCode, Cursor, Claude Code, etc). One honest caveat: on Windows there's no service install yet, so the binary has to be actively running for MCP or Web UI to work on windows. The biggest reason I think Lific is different than a lot of the other options is the lightweight nature of it alongside still having a fully featured web UI. It's meant for self hosters to work on big projects with agents, without sacrificing the other benefits of an issue tracker like a nice management UI or authentication for teams using it. Would genuinely love feedback and bug reports either here or on the discord! https://lific.dev July 17, 2026 at 11:22PM

Show HN: Rudo - A small, elegant dock for Wayland https://ift.tt/BDuXye0

Show HN: Rudo - A small, elegant dock for Wayland https://ift.tt/Jnik7oG July 17, 2026 at 01:12AM

Show HN: Tree, truth, druid, dryad, and tar share one Proto-Indo-European root https://ift.tt/NfSJZhF

Show HN: Tree, truth, druid, dryad, and tar share one Proto-Indo-European root https://ift.tt/cegJMHA July 16, 2026 at 11:11PM

Show HN: SirixDB 1.0 Beta – Git-Like Versioning, Diffs, Time-Travel Queries https://ift.tt/f7dBJF2

Show HN: SirixDB 1.0 Beta – Git-Like Versioning, Diffs, Time-Travel Queries Hi HN! I've posted SirixDB here before, back in 2019 ( https://ift.tt/sd9Mrvh ) and again in 2023 ( https://ift.tt/M9IjZ0G ). The core idea behind SirixDB is, that history is a first-class citizen. Every commit stores a lightweight, queryable revision. You can query any point in time, even individual nodes (for instance JSON values), diff arbitrary revisions, and efficiently track how data evolved without replaying events. Unlike traditional event stores, historical states do not need to be reconstructed by replaying events nor do we have to think about projections. Revisions are directly queryable. A simple example: Jan 1: Record "Price = $100, valid from Jan 1". Stored on Jan 1 (transaction time). Jan 20: Discover price was actually $95 on Jan 1. Commit correction. After correction, you can ask across both axes: - "What did we THINK the price was on Jan 16?" -> $100 (Transaction time) - "What WAS the price on Jan 1?" -> $95 (Valid time) I've worked on this in my spare time since 2013, following its academic precursor (Idefix/Treetank) at the University of Konstanz. The architecture relies on an append-only physical log and a persistent copy-on-write page trie. A high level view of the architecture: Physical Log (append-only, sequential writes) ┌────────────────────────────────────────────────────────────────────────┐ │ [R1:Root] [R1:P1] [R1:P2] [R2:Root] [R2:P1'] [R3:Root] [R3:P2'] ... │ └────────────────────────────────────────────────────────────────────────┘ t=0 t=1 t=2 t=3 t=4 t=5 t=6 → time Each revision is indexed, and unchanged pages are shared: [Rev 1] [Rev 2] [Rev 3] │ │ │ ▼ ▼ ▼ [Root₁] [Root₂] [Root₃] │ │ │ │ │ │ │ └─────────┐ │ └────────┐ │ └─────────┐ ▼ ▼ ▼ ▼ ▼ ▼ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │ P1 │ │ P2 │ │ P1' │ │ P2' │ └──────┘ └──────┘ └──────┘ └──────┘ Rev 1 Rev 1+2 Rev 2+3 Rev 3 (shared) (shared) Beneath the root pages sit node and secondary indexes, using a novel sliding-snapshot algorithm to balance read/write performance. Everything is queryable using JSONiq via the Brackit compiler. Back in 2019, and even in 2023, SirixDB was very slow due to GC pressure. Unlike most other document stores, SirixDB stores fine-grained nodes, and I came to realize that an on-heap (JVM) representation made up of lots of small objects simply didn't make sense. I measured it with async-profiler — with some help from Andrei Pangin himself — and the result was that the poor throughput was due to the sheer amount of allocations which scaled almost linearly with the number of open transactions. Working a full-time software engineering job, I lacked the energy for a massive spare-time rewrite. About a year ago, I started experimenting with AI. It turned out to be ideal for automating the tedious, repetitive parts of migrating the storage layer to Java's Foreign Function & Memory API, storing pages completely off-heap. Looking further ahead, the append-only, immutable-page design maps naturally onto object storage like S3 and distributed logs like Kafka for a cloud version, and initial prototypes already exist. Maybe that becomes a commercial service one day, but for now, I'm just thrilled to see these core design principles finally proven out.There's an interactive demo, documentation, and the code is on GitHub. I'd love feedback and am happy to answer questions! kind regards Johannes [1] https://sirix.io | https://ift.tt/KOCgxSv [2] https://ift.tt/RGJQ0Bn [3] https://demo.sirix.io [4] https://sirix.io/docs/ [5] http://brackit.io https://ift.tt/KOCgxSv July 15, 2026 at 09:16PM

Show HN: Leet Robotics: Learn robotics and ROS2 with hands-on courses https://ift.tt/rAZ5WDq

Show HN: Leet Robotics: Learn robotics and ROS2 with hands-on courses Hi all, I've just launched Leet Robotics: a platform to learn robotics hands-on, with a full ROS2 workspace that runs in the browser (Jazzy, Gazebo Harmonic, Foxglove, VS Code) - no install required. The platform also has room for sharing projects and simulation assets as it grows. Our first course is live now: Intro to ROS2 (free to read). The course teaches skills ranging from building your first node to a capstone project of a robot touring a museum world, with every lesson runnable in the online workspace (free accounts get an hour of workspace time daily - enough to follow the course). Would love feedback from this community: on the course, the workspace experience, and what courses to build next. https://ift.tt/vSqxdnz July 15, 2026 at 05:44PM

Show HN: Beautiful Type Erasure with C++26 Reflection https://ift.tt/snjTVE2

Show HN: Beautiful Type Erasure with C++26 Reflection Try it on Compiler Explorer: https://ift.tt/ZVJdl0a Check out the source code: https://ift.tt/wuaLFt4 https://ryanjk5.github.io/posts/rjk-duck/ July 14, 2026 at 06:10PM

Show HN: Find Remote Accounting Jobs https://ift.tt/V8cden0

Show HN: Find Remote Accounting Jobs https://ift.tt/qZz1oNg July 13, 2026 at 11:47PM

Show HN: Scramble Quest https://ift.tt/UdhOgGe

Show HN: Scramble Quest https://ift.tt/UHSfy80 July 12, 2026 at 11:28PM

Show HN: Sqlsure – deterministic semantic checks for AI-generated SQL https://ift.tt/sYeTAKt

Show HN: Sqlsure – deterministic semantic checks for AI-generated SQL https://ift.tt/bKHXwPc July 12, 2026 at 01:33AM

Show HN: Don't let your engineering brain rot in the age of AI https://ift.tt/gqL9JiM

Show HN: Don't let your engineering brain rot in the age of AI https://ift.tt/VfSz0RK July 12, 2026 at 01:27AM

Show HN: Share and explore custom Claude Code status lines https://ift.tt/5sve4uO

Show HN: Share and explore custom Claude Code status lines Hey HN, I made a registry for claude code users to share and explore status lines. I found that my friends/coworkers and I would always share screenshots of our terminal to show off our custom claude lines so I decided to build this registry as a place for others to show off! https://claudelines.com July 12, 2026 at 01:21AM

Show HN: We beat Cloudflare's bot detection (open-source stealth browser) https://ift.tt/YyDUmBQ

Show HN: We beat Cloudflare's bot detection (open-source stealth browser) https://ift.tt/4z3Jcjq July 11, 2026 at 05:56AM

Show HN: SubjectiveZero, an open-source agentic node editor for creative coding https://ift.tt/mr3N0GZ

Show HN: SubjectiveZero, an open-source agentic node editor for creative coding Hey there, My name is Clem, I've been a solo indie dev for a couple years now, exploring frontier tech like XR and agentic workflows in the context of creative / interactive work. I've been building creation tools for a while and some common design challenge is to figure out the right level of abstraction for your tool. You can always make it super advanced and complex with low level concepts (shader composition, actual code etc.) but then you get something with a high complexity / learning curve. On the other hand, if you make your tool too high level, it might be easier to use at first, but people will most likely hit a wall eventually and start fighting with your tool to get their edge case done (you see that on mobile a lot actually). With this prototype (called SubjectiveZero), I'd like to imagine that we can kind of move the "slider" on the abstraction layer, meaning that you can actually start with prompts that describe the goal, and you can go as high level (stay with abstract prompts) or low level as you'd like (more specific prompts, or even edit the generated code directly)! The agent orchestration actually understand your context and work along side with you to figure out what could be the best node graph structure for your project (that and some fun little procedural UI done at the node level). If i had to pitch it in 30 seconds, I'd say "Think TouchDesigner and friends but with agent orchestration". When you use it, it will generate real native code (Swift/Metal for now) that you can actually hot reload and iterate on either manually or through agents. It's still an early prototype and macOS only for now, but I'd love to get genuine feedback that could help me drive where this project should go next (or not). Lastly, I'm absolutely open and upfront on the fact that I used agentic coding for this, but as people say: "kept on a short leash". The architecture and specs were relatively well thought out and I personally prefer to be in the loop and review all the code being written to make sure it's going in the right direction. Oh and it's open source :-) Hope you like it! https://ift.tt/Ks2GPwz https://ift.tt/Ks2GPwz July 10, 2026 at 08:53PM

Show HN: Wyrm – Solve algebra by touch, built on an open-source soundness engine https://ift.tt/c39dMLX

Show HN: Wyrm – Solve algebra by touch, built on an open-source soundness engine There is a mobile game called DragonBox. It sort of tricks you into learning algebra by starting with very abstract manipulations of a puzzle that must follow rules... gradually the game teaches you more and more rules and also strips out the more abstract elements until on the last levels you are finally solving real equations. I loved it, it taught my kids algebra.... and it was just fun. Over the years I often thought that there should be a calculator for Algebra that works this way... something where you can drag terms around and cancel & distribute with gestures, but most importantly enter your own problems. It should also do more kinds of problems than DragonBox allowed. So I finally decided to build it. https://dicroce.github.io/wyrm/home.html Here's a video showing it: https://www.youtube.com/watch?v=_STbS4zvIlU . If you'd rather just play with it: there's a limited in-browser demo (real engine, a few example equations, no download) on the landing page — https://dicroce.github.io/wyrm/home.html . The app can be found on iOS ( https://ift.tt/5CI1tEG ) and as of this week on Google Play ( https://ift.tt/0H7RAm2... ). I also decided to open source the underlying math engine so others could build on it: https://ift.tt/P1iHdqQ . My goal for the engine btw is to build it all the way up to Calculus. Monetization is deliberately boring: the engine is free (MIT), and the polished gesture app is $4.99 once. No subscriptions, ads, accounts, or analytics. I'd love feedback on the engine design — especially from anyone who's worked on CAS or proof-assistant-adjacent problems. And if you played DragonBox as a kid and wished it went further: this is for you! https://ift.tt/P1iHdqQ July 9, 2026 at 04:46PM

Show HN: Real-time n-body tree code in CUDA https://ift.tt/wuI09sD

Show HN: Real-time n-body tree code in CUDA Sharing an old project of mine, on my RTX 500 Ada laptop GPU, it can simulate up to 4 million particles at ~400 ms per step using the Barnes-Hut algorithm, saturating the 4GB of VRAM available. The octree construction is fast, as well as the traversal. The major bottlenecks are the VRAM usage (1 million bodies require ~1GB), which could be probably halved by reusing intermediate buffers, and the particle to leaf evaluation, which would benefit from more fp32 FLOPS. Moreover, I still don't have a good heuristic to predetermine the size of the BFS queue, perhaps some sort of memory paging could solve the issue. https://ift.tt/V5k6CwM July 10, 2026 at 09:17PM

Show HN: Getting GLM 5.2 running on my slow computer https://ift.tt/wUr2mso

Show HN: Getting GLM 5.2 running on my slow computer The capabilities and security I was getting from this LLM are similar to those I've gotten from models like Claude or GPT, and this really surprised me. But then I thought, "I wonder how it would work on a normal computer like mine," and above all, "I wonder if it would work without going into OOM on a computer like mine." So I started working with the help of agents to test this possibility. I started converting the model to int4, understanding MTP usage, and if possible implementing DSA for long context. How it responds in int4 and whether the quality is maintained or not. Until I got to the point, on my computer with 32GB of RAM, I was able to communicate with GLM 5.2 with times that, of course, aren't high in cold start, but even then, we're talking about 0.1 tok/s, but that wasn't important to me. The important thing was the journey to reach this goal and, above all, changing the perspective on the project. I wanted it to work at all costs, even slowly. So I created Colibrì, which was born from a very simple idea, to be honest, but tested in every way, where a 744B Mixture-of-Experts model activates only ~40B parameters per token—and only ~11 GB of those change from token to token (the routed experts). So: The dense part (attention, shared experts, embeddings—~17B params) stays resident in RAM at int4 (~9.9 GB); The 21,504 routed experts (75 MoE layers × 256 experts + the MTP head, ~19 MB each at int4) live on disk (~370 GB) and are streamed on demand, with a per-layer LRU cache, an optional pinned hot-store, and the OS page cache as a free L2. The engine is a single C file (c/glm.c, ~1,300 lines) plus small headers. No BLAS, no Python at runtime, no GPU.No GPU or serious hardware because I don't have that hardware so I can't test it on hardware that is more powerful than my computer.Colibrì is a one-person project, written and tested entirely on a 12-core laptop with 25 GB of RAM — the numbers above are the ceiling of what I can measure at home. Any feedback is welcome! Repo: https://ift.tt/bQ8Xi2v https://ift.tt/bQ8Xi2v July 9, 2026 at 01:35PM

Show HN: Codex Explorer, a local session manager for Codex CLI https://ift.tt/G6Vp92a

Show HN: Codex Explorer, a local session manager for Codex CLI https://ift.tt/zpRKMbi July 9, 2026 at 11:53PM

Show HN: Onboard-CLI, a LLM powered and AST-based tool to visualize codebase https://ift.tt/CNG9Kda

Show HN: Onboard-CLI, a LLM powered and AST-based tool to visualize codebase https://ift.tt/UEXyNsS July 9, 2026 at 01:39AM

Show HN: Skill-extractor turns coding agent transcripts into reusable skills https://ift.tt/JtLaQHI

Show HN: Skill-extractor turns coding agent transcripts into reusable skills https://ift.tt/HK7fx4M July 9, 2026 at 01:33AM

Show HN: REST - Living Without Burnout. A manifesto about sustainable discipline https://ift.tt/lW7iT84

Show HN: REST - Living Without Burnout. A manifesto about sustainable discipline Lately, I’ve been thinking a lot about what gives me energy and what slowly takes it away. Those thoughts eventually turned into a small manifesto I called REST. https://themanifesto.rest/ July 9, 2026 at 01:12AM