The Internet Is Drowning in AI Slop, but These Projects Still Feel Human
Yesterday I opened GitHub and realized most of my feed looked like AI agents reviewing pull requests written by other AI agents. Half the trending repositories were prompt wrappers. The other half were markdown files explaining how to convince a chatbot to behave slightly differently.
At some point, software culture quietly shifted from building things to orchestrating APIs.
And yet, underneath all of that noise, there are still developers making strange, ambitious, deeply creative projects that remind you why programming used to feel exciting in the first place.
Not optimized for engagement. Not built around growth hacks. Just people making weird software because they can.
These are the kinds of projects that restore a little faith in the internet.
Ratty: A Terminal Emulator That Treats Your Shell Like a Video Game
Most terminal emulators try to disappear into the background. Ratty does the opposite.
Built in Rust and inspired by TempleOS aesthetics, Ratty renders your terminal as a fully GPU-accelerated 3D environment using the Bevy game engine. The cursor alone is a spinning 3D rat. You can tilt the terminal in physical space, import custom 3D assets, and generally turn your shell into something that looks more like a PS2 game than a developer tool.
It’s wildly unnecessary.
It also consumes around 300MB of RAM, which would normally be a dealbreaker for terminal software. But that’s also what makes the project interesting. Nobody building Ratty was asking, “Will enterprise users adopt this?”
They were asking, “Can we make terminals absurdly fun again?”
That mindset matters more than people realize.
A lot of memorable software comes from developers following curiosity instead of product-market fit.
Terminal Phone Is the Most Cyberpunk Thing Built in Years
One of the more interesting open-source releases this year is Terminal Phone — a push-to-talk voice and messaging system that runs entirely from the terminal over Tor.
No accounts.
No centralized servers.
No phone numbers.
Your identity is simply an onion address.
The implementation itself is surprisingly ambitious for what initially sounds like a joke project. The protocol was built from scratch, communication is end-to-end encrypted, and the whole thing operates as a shell-based application.
What makes it compelling isn’t just the privacy angle. It’s the refusal to accept the assumptions modern apps are built around.
Most communication software today assumes permanent identity, centralized infrastructure, analytics, and account systems. Terminal Phone strips all of that away and replaces it with something far more temporary and developer-driven.
It feels closer to the old internet philosophy where tools existed because someone believed they should exist.
CUDA Oxide Might Be One of the Most Important Rust Projects This Year
Not every interesting project comes from indie developers.
NVIDIA recently released CUDA Oxide, a Rust-based approach for writing GPU kernels without touching C++.
If you’ve ever worked with CUDA directly, you already know the pain points:
- complicated memory management
- unsafe pointer-heavy code
- compiler instability
- debugging sessions that destroy entire weekends
CUDA Oxide attempts to move GPU programming into a safer environment by compiling Rust directly into PTX. No C++ interoperability layer. No FFI gymnastics.
That’s a significant shift.
For years, Rust has been slowly expanding into areas traditionally dominated by C and C++. GPU programming always felt like one of the harder frontiers because of how tightly coupled CUDA tooling is to NVIDIA’s ecosystem.
This project suggests that boundary is finally starting to crack.
And honestly, it’s overdue.
Honker Proves Most Apps Don’t Need Kubernetes
There’s a category of software I immediately respect: projects that aggressively simplify infrastructure instead of adding more layers to it.
Honker falls into that category.
At its core, it’s a SQLite extension written in Rust that adds PostgreSQL-style LISTEN/NOTIFY behavior directly into SQLite.
That means you can build:
- durable pub/sub systems
- task queues
- event streams
- cron scheduling
…without introducing Redis, RabbitMQ, Celery, or an entire distributed systems stack.
Everything lives inside the same SQLite database file.
This is one of those projects that quietly challenges modern backend culture.
A huge percentage of applications today are massively overengineered relative to their actual scale. Developers deploy Kubernetes clusters for products with 12 active users. Entire infrastructures exist to solve problems that never appear.
Honker feels like a reminder that simplicity still scales surprisingly far when the fundamentals are good.
SQLite continues to be one of the most underestimated pieces of software ever written.
WarioSynth and the Joy of Pointless Creativity
Some projects exist purely because they make the internet more entertaining.
WarioSynth takes songs and recreates them as Game Boy-style chiptunes directly in the browser using the Web Audio API.
No server-side processing.
No AI-generated marketing layer.
Just browser audio engineering and nostalgia.
Technically, the implementation is impressive. Reconstructing music with limited Game Boy-style channels requires careful synthesis work, especially when trying to preserve recognizable melodies.
But what I like most is that nobody needed this project to exist.
The developer built it because it sounded fun.
That kind of motivation used to be far more common in software development before everything became optimized for monetization or “founder mode” content.
Wikipedia as a TikTok Feed Shouldn’t Work This Well
One of the smartest ideas on this list is Exipedia, which turns Wikipedia browsing into an infinite scroll feed.
You choose topics, the app downloads a lightweight dataset from Simple Wikipedia, and then serves educational content in a format that feels native to modern scrolling behavior.
Normally I’d hate this idea on principle.
But after trying it, I kind of get it.
Developers often complain about short attention spans while continuing to design products around the exact mechanics that create them. Exipedia does something more practical: it accepts how people already consume information and redirects that behavior toward something useful.
That’s a much more realistic approach than pretending users will suddenly become disciplined readers again.
The Browser Is Quietly Becoming an Operating System
Puter is another project that deserves more attention.
It’s essentially a self-hostable desktop environment running in the browser, complete with windows, applications, file management, and developer tooling.
This concept has existed in various forms for years, but what makes Puter interesting is how polished and usable it already feels.
The modern browser has evolved into an absurdly capable runtime environment. Between WebAssembly, browser APIs, GPU acceleration, and local storage, web applications are now capable of things that would have sounded unrealistic a decade ago.
Projects like Puter make that transition visible.
We’re getting closer to a world where the distinction between “web app” and “desktop software” matters less every year.
Weird Software Is Still the Best Software
A lot of the most memorable developer projects have something in common:
They solve problems nobody asked to solve.
Or they solve ordinary problems in hilariously excessive ways.
That’s not inefficiency. That’s experimentation.
The software industry right now feels heavily optimized toward predictability. Every startup copies the same stack. Every AI product ships the same interface. Every productivity app eventually converges into the same beige dashboard.
The projects worth remembering usually come from developers ignoring those patterns completely.
And honestly, that’s probably healthy for the ecosystem.
Because once software becomes purely practical, it also becomes forgettable.
The internet still needs people building strange things in Rust at 2AM for absolutely no reason other than “this would be cool.”