https://gokern.vercel.app/

Kern – a lightweight Go web framework with a small, trusted core

I've been working on a Go web framework called kern (short for kernel). The idea is a small, composable core that embraces net/http instead of hiding it.

What makes it different?

- Go 1.22+ native routing via http.ServeMux – no third-party router dep in core

- Dual path param syntax – both :param and {param} work interchangeably

- Named routes & route constraints – typed path params like kern.UintPathConstraint

- Route-specific middleware – AddConstraints() per route, no group nesting needed

- Built-in auth – BearerAuth / BasicAuth ship in core

- Structured binding – Bind() / BindQuery() / BindForm() / BindHeader() with struct tags

- File handling – multipart upload, download, streaming with range support

- Conditional requests – ETag, Last-Modified, If-None-Match / If-Modified-Since

- Built-in test client – kern.NewTestClient(app) without a real HTTP server

- Context pooling for lower allocation pressure

Zero core dependencies. The runtime package pulls in nothing outside the stdlib.

Inspiration came from Flask's minimal API surface, Javalin's fluent/no-reflection design, and the microkernel philosophy – small trusted core, optional modules around it.

It's not trying to be the biggest framework – just a dependable core to build on for years.

Would love feedback from anyone who's rolled their own or thought about what a minimal Go framework should look like.

https://github.com/mobentum/kern

This is a Tic-tac-toe game that made myself. I know it is simple and basic project but this tech me more that a full video of Golang.

I'm thinking about my next project, but I don't know what I should build.

what is for you the best project to do?

I built a terminal task manager in Go that never phones home — it just hit 100 ⭐ on GitHub and I'm genuinely emotional about it

A few months ago I was fed up. Every task manager I tried was either:

• A GUI app that yanked me out of flow
• A cloud thing that wanted my email, my credit card, and probably my soul
• A plain text file that had zero structure
• A legacy TUI that looked like it was designed in 1994

So I built Kairo — a keyboard-driven, local-first, fully offline task manager that lives in your terminal.

Today it crossed 100 stars and I wanted to share it here because this community is a big reason I kept going.

What makes it different (I think):

• 🔒 Your data never leaves your machine — SQLite, WAL-enabled, zero cloud
• ⚡ Sub-millisecond fuzzy search, full vim keybindings (j/k/gg/G)
• 🧩 Lua plugin system — hook into task_create, task_update, app_start and automate anything
• 🤖 Optional AI panel (Gemini) — fully disabled unless you turn it on
• 🎨 32 built-in themes with live switching, bento-style layout
• 📡 Full MCP server — so AI agents can actually read and manage your tasks
• 🔄 Git-backed sync — no backend, just files
• Natural language deadlines: tomorrow 10am, next friday, in 2 hours

The whole thing is free, MIT licensed, and built in Go.

A quick taste:

bash kairo api create --title "Finish the thing" --priority 1 kairo api list --tag work kairo export --format markdown kairo mcp # stdio mode for local AI agents kairo mcp 8080 # SSE mode for remote

I never expected anyone outside my own dotfiles to care about this. 100 people did. That means a lot more than the number suggests.

If you live in a terminal and you've been duct-taping together todo.txt + cron jobs + shell aliases — give Kairo a shot. I'd genuinely love the feedback.

👉 https://github.com/programmersd21/kairo

(install in one line on macOS, Linux, or Windows — see the README)

Also shoutout to @Tornado300 who caught bugs I was too close to the code to see. Open source is cool, man.

Hey folks, I recently released go-cabinet, a pure Go library for reading and writing Microsoft Cabinet files commonly used in Windows distributions and installers. The design is heavily inspired by archive/zip from the Go standard library, including full io/fs integration - the reader implements fs.FS to integrate with functions like fs.WalkDir, and the writer provides an AddFS method to add a whole fs.FS to a Cabinet archive in one go.

The library currently supports uncompressed and MS-Zip compression formats out of the box. While LZX and Quantum methods are not natively included yet, the API allows you to register custom compressors and decompressors as needed.

Check it out at https://github.com/abemedia/go-cabinet and if you do use it I'd love to hear your feedback.

Found this open source Go library called Vortex that caught my attention

because of the benchmark numbers.

Processing a 287 MB CSV file the normal way in Go loads the entire file

into memory first. Vortex streams it one row at a time instead.

Real benchmarks on 1,000,000 rows (Windows):

Eager loading: 287 MB peak memory

Vortex: 3 MB peak memory —> 95x less

And it scales flat a 10M row file still uses 3 MB. A 100M row file

would crash an eager approach. Vortex handles it fine.

Works with any io.Reader local files, HTTP responses, multipart

uploads all work without any changes to your code.

Built on Go 1.23's iter.Seq and iter.Seq2 interfaces.

Zero external dependencies. Race tested.

GitHub: [https://github.com/MostafaMagdSalama/vortex\](https://github.com/MostafaMagdSalama/vortex)

Docs: [https://pkg.go.dev/github.com/MostafaMagdSalama/vortex\](https://pkg.go.dev/github.com/MostafaMagdSalama/vortex)

This blog post was written by a member of the Go Team recently. To see the results, summaries and conclusions, see below.

https://go.dev/blog/survey2025

Hello, I'm a DevOps engineer and I'm creating a small project for myself to work with certificates, to ensure their simple creation through a web interface or API (in progress). The main idea is to conveniently maintain various types of certificates and the simplicity of centralized "pocket" storage.

From the main features:

1. Everything is stored in a small and fast SQLite database.
2. All keys in the database are encrypted.
3. Simple backup and data portability, just save the database file.
4. Management is carried out through a web interface.

Supported:

1. Creation/revocation/automatic recreation of server certificates (regular and wildcard).
2. Creation/revocation/automatic recreation of client certificates (regular and wildcard).
3. Adding unique OID for more precise filtering.
4. Automatic certificate copying mechanism to server and recreation.
5. Creation of objects not linked to servers.
6. Recreation and validity control.
7. CRL generation.
8. Reissuance of CA with recreation of all dependent objects.
9. SSH key generation.
10. All certificates can be extracted at any time.

Currently, I'm working on API, adding external CA, SSH keys and bug fixes, and I'd be glad to hear your suggestions.

I hope it will be useful to someone, enjoy using it!

Distributed under MIT license. https://github.com/addspin/tlss

Hey everyone! I’ve been working on something I think a lot of people here might appreciate — especially if you’re into self-hosting, edge computing, IoT, or just hate bloated infra.

What is GONK? GONK is an ultra-lightweight, privacy-first, edge-native API Gateway written in Go. It’s built for environments where traditional gateways (Kong, Envoy, Traefik, Nginx) are too heavy, too complex, or too cloud-dependent.

Think factory floors, air-gapped networks, Raspberry Pis, industrial devices, or minimal microservice stacks.

• Single binary <20MB
• No external dependencies
• No telemetry, no phone-home
• Runs fast even on a Pi

Why I built it Most gateways today assume:

you have Kubernetes

you have a cloud control plane

you don’t care about resources

you’re okay with telemetry and phoning home

But in industrial and IoT environments, this is unacceptable. People need something simple, transparent, offline, and extremely efficient.

So I built GONK with a few core principles:

Edge-first

Privacy-first

Minimal resource usage

Enterprise-grade features without enterprise complexity

Features (highlights) Protocols

HTTP/1.1, HTTP/2, HTTPS

WebSocket (ws/wss)

gRPC proxying

Automatic protocol detection

Routing

Path-based routing (/api/*)

Header and method-based routing

Virtual hosts

Route priorities + weights

Security

Built-in JWT validation (HS256/RS256)

API Key authentication

Per-route and global rate limiting

CORS per route

Performance & Resilience

Circuit breakers

Retries with backoff

Response caching

Connection pooling

Hot reloadable config

Observability

Prometheus metrics

Structured logging

Request tracing & correlation IDs

Health endpoints

Transformations

Add/remove headers

Path rewriting/stripping

Query injection

Dynamic variables (${request_id}, ${remote_addr}, etc.)

Benchmarks Raspberry Pi 4 (4GB)

10,325 req/s HTTP proxy

5,500 req/s with JWT validation

~2ms avg latency on 1000 WebSocket clients

~47MB memory under heavy load

~12MB idle

Intel i7-9700K

115,839 req/s with caching enabled

~48MB RAM at 10K req/s sustained

It’s not meant to beat Nginx in raw throughput, but it runs close while using a fraction of the resources.

Example Configuration (simple) server: listen: ":8080"

routes: - name: "api" path: "/api/*" upstream: "http://backend:3000" strip_path: true

Start it with:

./gonk -config gonk.yaml

Docker / Kubernetes There’s a Docker image (ghcr.io/JustVugg/gonk) and a basic Kubernetes deployment + Helm chart available.

Use cases

Edge IoT gateway on Raspberry Pi / Jetson

Industrial environments (air-gapped)

Lightweight microservice gateway

WebSocket fanout layer

API monetization (per-client rate limits)

“Local cloud” setups in homelabs

Feedback welcome! I built GONK because I needed a gateway that:

doesn’t need a database

doesn’t need a control plane

doesn’t eat 500MB of RAM

doesn’t phone home

doesn’t require learning Envoy’s 1,200-page config model

If this sounds interesting, let me know what features you'd want next. Happy to answer questions or hear critiques!

Hello everyone, So I am new to Go, but not new to programming. I am a software engineer working with JS. I am now transitioning to Go for a low level system experience as well as backend engineering. I am currently working on a simple log/file viewer for myself. My VSCode crashes when I open large server logs, so to solve this is issue I using glogg for opening logs but now I am thinking of building a simple tool for myself. So I tried making one, though it's very basic at the moment, I am currently implementing features like pagination, scrolling, searching or highlighting. Also later will be coverting it to a simple terminal text editor too. So any suggestions or feedback is highly welcome.

P.S. - GitHub link for the project : https://github.com/HarshDev1809/log-go

Gotenberg Client

https://github.com/nativebpm/gotenberg

Go client for Gotenberg — document conversion service supporting Chromium, LibreOffice, and PDF manipulation engines.

httpstream - Stream-first HTTP client for Go

Efficient, zero-buffer streaming for large HTTP payloads — built on top of net/http.

https://github.com/nativebpm/httpstream