One tradeoff in my architecture-testing crate is that it reads Rust source without asking the compiler which feature combination is active. It keeps cfg branches together in the dependency graph.

For example, suppose the core of a project must not depend on its SQLite adapter. This import is still a dependency for the architecture check:

#[cfg(feature = "sqlite")]
use crate::sqlite::Connection;

It doesn't disappear from the check just because the default Cargo features omit sqlite. Ordinary imports between files inside the core can remain allowed.

That is useful if the rule means “keep this boundary in every feature variant represented in the source”. You can catch the feature-gated shortcut while working on the default configuration.

The price is precision

This is a conservative source graph. Mutually exclusive branches can appear together, so a cycle in that graph is not proof that the cycle exists in one actual build. It also doesn't expand macros or inspect build-script-generated source. If you need the exact dependency graph of a compiled variant, this analysis isn't that.

The crate is archunit 0.0.2, free and MIT licensed. Project: https://github.com/dragonsec-ai/ArchUnitRust

A repo's folder tree tells someone where the code lives. It doesn't show which parts depend on which others.

I maintain ArchUnitTS, and one feature you can use without first designing a set of architecture rules is its dependency report. It can collapse files into folders and export HTML or Mermaid.

For a small tool with parsing, storage and a CLI, a folder-level view is often more useful to a new contributor than a diagram with every file on it. It gives them a way to see that parsing has started depending on CLI code, for example, before they decide where a new option belongs.

The report is generated locally from the dependencies the analysis resolves. You can keep a Mermaid export with the documentation or share the HTML alongside the project.

The graph isn't a runtime trace, and a clean-looking picture isn't proof of good architecture. It is a concrete view you can discuss while the project is still small enough to change.

Source: https://github.com/LukasNiessen/ArchUnitTS

Hey all 👋

What it is:

• A KAN implementation completely from scratch, inspired from the micrograd by Andrej Karpathy

• Each edge is a cubic B-spline plus a SiLU term, with my own Cox-de Boor recursion

• A tiny reverse-mode autograd engine in the style of micrograd. Every node lives in a NeuronPool (a std::deque, so pointers never go stale). The creation order is already the topological order, so backprop is one reverse loop, with no DFS.

• Each spline edge is a single graph node that stores its own partial derivatives (local_grad), so the forward pass does all the spline work and backward never re-evaluates it

• 70 parameters, ~0.15 s to train in C++

The bench: I put it up against micrograd’s MLP (67 params) on y = 3x² + 7x + 2. Both used per-sample SGD for 200 epochs, with the median taken over 5 seeds.

The caveats:

• The speed gap is mostly C++ vs interpreted Python, so don’t read it as KAN vs MLP.

• It’s a tiny 1-D regression with 9 training points.

• It shows the thing learns correctly, not that KANs beat MLPs in general. A smooth polynomial just happens to suit splines.

Known rough edges (they’re listed in the README):

• w_out is shared across the outer edges.

• No grid refinement or pruning.

• It’s fixed to 2 inputs for now.

All the critics are welcome!!!

🔗 GitHub: https://github.com/spyke7/microkan
Stars and issues are welcome ⭐

I've been working on ArchUnitGo, an open source library for testing the structure of a Go project. I recorded a short demo because the workflow is easier to show than explain in a feature list.

You select part of the codebase, describe a rule, and run it through the normal Go test runner. For example, the API folder shouldn't depend on the database folder. When that rule fails, you get the files involved in the dependency.

The interesting implementation detail is that building a rule is separate from running it. The builders are immutable, so you can reuse a selection and give it several different checks. The library reads the project when you actually evaluate the rule.

It's a development tool rather than a runtime component. The current release requires Go 1.26+, and the API is still pre-1.0.

Repo: https://github.com/dragonsec-ai/ArchUnitGo

My current side project, dm me if you want to try it out

I put together a repo for guiding a coding agent through an LG webOS TV cleanup: a simple app launcher, supported privacy settings, compatibility checks, and recovery.

The setup uses a bind mount over the native Home entry point with a small stand-in that launches the custom launcher. Independent root SSH must work before enabling the takeover, and a saved restore command returns the stock Home. The runbook includes validation with the remote, a physical cold boot, and streaming playback.

The interesting programming problem here is coordinating software changes with checks a remote agent cannot establish from API responses alone. I'd appreciate feedback on the helper scripts, validation steps, and recovery procedure.

Repo: https://github.com/amiable-ostrich/lg-tv-clean

The repo is free to download. It contains a setup runbook, coding-agent instructions, and host/runtime helpers. Running the workflow requires your own coding agent with terminal access; any cost depends on the agent you use.

Reference setup: **LG 55UQ7570PUJ, webOS 7.6.0, firmware 04.60.91**. The custom Home replacement requires root. Other models need exact-firmware compatibility checks and adaptation; this is not a universal installer. Optional privacy/domain controls do not eliminate all tracking.

Upstream credit: [Clean Your TV](https://github.com/Razdva122/clean-your-tv-lg-webos) for the launcher base, [SlopBro](https://github.com/throwaway96/slopbro) for rooting, and [webOS Homebrew Channel](https://github.com/webosbrew/webos-homebrew-channel) for homebrew infrastructure. My contribution is the documented coding-agent workflow and helper scripts around those projects.

GPTmail is my early MIT-licensed email-workspace project: https://github.com/ozandikici/GPTmail

The backend is Python/FastAPI with Upstash Redis REST persistence; the UI is HTML/CSS/vanilla JavaScript. It connects compatible IMAP/SMTP accounts to a password-protected, single-owner dashboard. An OAuth-protected integration lets ChatGPT request selected actions.

The implementation separates mailbox credentials from assistant permissions. Each tool is checked at execution, write permissions start disabled, and sending or moving mail to Trash can wait in a dashboard approval queue. Pending outgoing actions also recheck the originating permission at approval time.

I am sharing the source for feedback on the implementation and setup docs. There are 69 automated tests that passed during development, including mocked provider flows. Live Gmail/Microsoft interoperability still needs testing, and their OAuth setup requires registering provider applications. It has no independent security audit.

A useful next contribution would be a reproducible provider compatibility report or a test for a missed IMAP edge case. AI coding agents helped with implementation, tests, docs and this post.

**I built a job search aggregator that queries 12 platforms at once**

Tired of switching between tabs while job hunting, so I built a desktop app with Python/Tkinter that searches 12 job platforms simultaneously.

**No API key needed:**
Bundesagentur für Arbeit, Arbeitnow, RemoteOK, WeWorkRemotely, Remotive, Himalayas, The Muse

**Free API key required:**
Adzuna (19 countries), Reed (UK), Findwork (tech/remote), Jooble (70+ countries), HeadHunter (Russia/CIS)

**Tech:** Python · Tkinter · REST APIs

Check it out: https://todorvankov.com/job-search-tool

Feedback welcome – especially if something breaks 😅

Hi everyone! I created a COBOL editor for GnuCOBOL with a TUI (Terminal User Interface). I wanted to showcase this project, which I programmed entirely in C. If anyone is interested, you can check it out here:https://github.com/EntoNine/C.W.S.E.-Cobol-Work-Script-Editor

I know COBOL isn't very common these days, but if anyone here still codes in it, I’d really appreciate it if you could test the program and give me some feedback!

Hey r/programmingprojects! I built Resonance — a fully working desktop music player. Not a template, not a concept — there's an actual .exe you can download and run right now.

Download: https://github.com/akshDgr8lgnd/resonance/releases/tag/v0.1.3

What it does:

• Sound Capsule: playback heatmaps, weekly stats, listening streaks

• yt-dlp backed downloads with concurrency control

• iTunes + YouTube metadata search

• Smart library with auto deduplication

• Embedded HTTP server for future Android companion app

Stack: Electron + React + SQLite + TypeScript

Source code also on GitHub if you want to build from source or contribute.

GitHub: https://github.com/akshDgr8lgnd/resonance

I’m building Java Runner Client — a tool to easily run and manage your JARs without messy .bat files. It’s still in development, but here’s what it offers:

• Manage running JARs: Central place for all your JARs, no more batch files.

• Auto-start: Mark profiles to run JARs automatically when the app opens; auto-restart on crash.

• Profile system: One profile per JAR, with its own JVM args, system properties (-D), and program args. Profile templates for easy setup.

• Console tab: Live stdout/stderr, stdin commands, history, and Ctrl+L to clear.

• Configure tab: Set JAR path, working directory, Java executable, and all argument types per profile.

• Settings: Launch on Windows startup, start minimized, minimize-to-tray, console font size, word wrap, buffer limits.

• System tray: Always available, shows running processes, double-click to restore.

• Utilities: Process Scanner to kill orphaned JARs, Activity Log to track everything.

Check it out on GitHub: https://github.com/timonmdy/java-runner-client

Feedback and contributions are very welcome!

I had been making my own custom built Intel 8085 emulator in C++ for the past few days,now its been seeing some progress.Glad to share that it runs entierly inside the terminal and the terminal rendering has been custom developed by me with less and less bloat and max performance.Also the assembler seems to be working well. Glad to share it soon for learning purpose for the students

Built a 3D renderer from scratch in Python. No external 3D engines, just Pygame and a lot of math.

What it does:

• Renders 3D wireframes and filled polygons at 60 FPS

• First-person camera with mouse look

• 15+ procedural shapes: mountains, fractals, a whole city, Klein bottles, Mandelbulb slices

• Basic physics engine (bouncing spheres and collision detection)

• OBJ model loading (somewhat glitchy without rasterizaton)

Try it:

bash

pip install aiden3drenderer

Python

from aiden3drenderer import Renderer3D, renderer_type

renderer = Renderer3D()
renderer.render_type = renderer_type.POLYGON_FILL
renderer.run()

Press number keys to switch terrains. Press 0 for a procedural city with 6400 vertices, R for fractals, T for a Klein bottle.

Comparison:
I dont know of other 3D rendering libraries, but this one isnt meant for production use, just as a fun visualization tool

Who's this for?

• Learning how 3D graphics work from first principles

• Procedural generation experiments

• Quick 3D visualizations without heavy dependencies

• Understanding the math behind game engines

GitHub: https://github.com/AidenKielby/3D-mesh-Renderer

Feedback is greatly appreciated

I made a fun open-source fake CLI terminal in C — looking for contributors!

Hey! I built YigiTux, a fake shell written in C with easter eggs, ASCII art, hackmode, jokes and more.

It's MIT licensed, open source, and I want to grow it into a multi-language project. Solo dev so far — any feedback or PRs are welcome!

🔗 https://github.com/alpyigit7616/YigiTux

I’ve always found it difficult to stay focused or even start studying at all. For me, it mostly comes down to motivation.

how I made it:

• React + Vite + TypeScript

• Firebase (auth/data)

• Vercel (hosting)

This is still an early version, and I’m not claiming it’s anything groundbreaking, but I’d genuinely appreciate feedback on it.

Here’s the link if you want to try it:
study-pet.vercel.app