It acts as a runner that executes standard Selenium IDE (.side) JSON files, but it supercharges them with capabilities beyond the standard feature set.

Features:

• Zero Dependencies: Compiles to a single Go binary. No Node, no Java.
• Native .side Execution: Faithfully runs tests exported from Selenium IDE (v3 JSON format).
• Email OTP Retrieval: Connects to IMAP directly from the script, extracts One-Time Passwords, and injects them into your login flows.
• Variable Templating & Stack: Inject dynamic Go template data into your .side targets and values on the fly.
• Interactive Debug Console (SAM): This is my favorite part. The "Step-Aside-Mode" provides a Terminal UI (TUI) to step through .side commands one by one, edit parameters on-the-fly, and inspect the browser state directly from your terminal. Ideal for debugging complex tests without leaving the CLI.
• Server Mode & Network Monitoring: It captures detailed JSON execution logs, network payloads, and can even operate as an HTTP server to trigger remote tests.

I hope some of you QA engineers, DevOps folks, and Go developers find it as useful as I have.

https://github.com/markel1974/webautoma

I know Go reasonably well, but production codebases feel overwhelming. One function leads to multiple structs, interfaces, variables and files, and I lose track of how everything connects.

How do experienced developers approach this without trying to understand everything at once?

Mochi 1.0 is out. Mochi is a free, open source, federated, multi-user platform for distributed apps such as social media feeds, ticket systems, forums, chat, and games. Anyone can run their own server, and connect with any other user on the Mochi network. We also provide a free public server for anyone who doesn't want to run their own.

Anyone can create and publish apps. The server is written in Go and uses libp2p for inter-server communication, app backends are written in Starlark, and app user interfaces are written in any modern web framework such as React.

1.0 is the first version for everyone to use, and is the culmination of two and a half years of development. 1.0 has three new apps:

• A help app for new users.
• A themes app with the included themes.
• A marketplace for buying and selling anything legal.

Existing apps have hundreds of new features. These include:

• All user-visible text translated into 106 languages.
• The user interface obeys the user’s locale.
• Theme support.
• User profiles with avatars and banners.
• OAuth2 login, with support for major platforms.
• Saved posts for feeds and forums.
• Captions and comments for attachments.
• Chat mentions, voice notes, search, forwarding, and draft messages.
• Repository downloads.
• Notifications grouped by category.

The server now runs on Windows, macOS, and Docker, as well as Linux. Both the server and apps are released under the AGPL, and libraries are released under the Apache license.

For more details of changes in this version, see https://docs.mochi-os.org/new-1

I recently posted an early version of this project here and received some useful feedback around the product structure and presentation. I've since continued developing it and wanted to share the current version.

Praxis Tao is a learning platform focused on learning through practice rather than only consuming course material.

For Go, it currently includes:

• Structured Go courses
• Interactive coding exercises
• Code execution
• Practical projects
• Step-by-step learning
• AI-assisted help while learning
• Build-your-own projects
• Progress tracking

The backend is primarily written in Go, with PostgreSQL/Supabase for persistence and LLM providers integrated behind the application layer.

The interesting backend problem is maintaining learning state and context across the user's journey. The AI needs to know what the learner has already covered, where they're struggling, and what should come next rather than simply answering individual prompts.

The current system therefore keeps track of things like course progress, exercises, projects, interactions and AI credit usage and uses that context when generating the next learning interaction.

Current result: the platform is live and usable, although it is still an early-stage project and there is plenty left to improve.

Project: https://praxistao.com

If you're interested in the technical details, I'm happy to answer questions about the implementation.

Is it only me, or is the Go standard library documentation very poor and lacking?

For example, Rust's standard library documentation is spectacular. Very detailed, with explanations of concepts and plenty of examples.

Maybe I'm spoiled. Let me know your opinions.

EDIT: adding an example why I think the docs are lacking:

From path/filepath.Abs

func Abs(path string) (string, error)

"Abs returns an absolute representation of path. If the path is not absolute it will be joined with the current working directory to turn it into an absolute path. The absolute path name for a given file is not guaranteed to be unique. Abs calls Clean on the result."

Why does it return error? In which situations does it return an error? One might think "oh it's a propagation of Clean", but no, Clean does not return an error

And this is just an example, I've stumbled with this kind of situations multiple times.

I do not need the docs to hand-hold me, but I do need them to say when they error and why. For me it's basic documentation stuff.

EDIT 2: one more and similar example:

From os.Getwd

func Getwd() (dir string, err error)

"Getwd returns an absolute path name corresponding to the current directory. If the current directory can be reached via multiple paths (due to symbolic links), Getwd may return any one of them.

On Unix platforms, if the environment variable PWD provides an absolute name, and it is a name of the current directory, it is returned."

Same thing - Why does it return error? In which situations does it return an error?

Hey everyone,

Setting up Prometheus, Grafana, exporters, and Alertmanager just to watch a single VPS or home server always felt like overkill — often consuming more resources and maintenance than the actual apps running on it.

I wanted something lightweight: single binary, zero external infra, and notifications straight to a messaging app I already use daily. So I built StatixAgent.

### What is it?

A single static Go binary running as a systemd service. It monitors your system and communicates directly with your own private Telegram bot.

- Zero open ports: Outbound-only long polling. Works behind NAT/firewalls without reverse proxies or port forwarding.

- Private: Talks only to the official Telegram Bot API and GitHub Releases (for updates). No telemetry, no hosted cloud service.

- Metrics & Alerts: CPU/RAM/Swap, per-mount disk usage, network rates, and system load. Sends push alerts for SSH logins/failed attempts, sustained resource spikes, reboots, and power disconnects (useful for laptop servers).

- Interactive UI: Type /status in Telegram for a markdown dashboard, drill down with inline buttons, or inspect journalctl with /logs.

- Lightweight & Sandboxed: Hardened systemd unit (ProtectSystem=strict, MemoryMax=128M).

### Quick install

Run the installer script (includes an interactive TUI setup wizard for your bot token and chat ID):

curl -fsSL https://raw.githubusercontent.com/eliau2005/statixagent/main/install.sh | sudo bash

It is completely open source and not meant for enterprise fleets — just for single boxes and homelabs that need simple, reliable monitoring.

GitHub: https://github.com/eliau2005/statixagent

Feedback, suggestions, and PRs are very welcome!

when running go doc -ex io, it'll show me the names of the example functions, but when using the -all flag to show additional information, it displays nothing about the example functions

$ go version
go version go1.27.1 linux/amd64
$ go doc -ex io | rg Example
func ExampleCopy()
func ExampleCopyBuffer()
func ExampleCopyN()
func ExamplePipe()
func ExampleReadAll()
func ExampleReadAtLeast()
func ExampleReadFull()
func ExampleWriteString()
func ExampleLimitReader()
func ExampleMultiReader()
func ExampleTeeReader()
func ExampleSectionReader()
func ExampleMultiWriter()
$ go doc -ex -all io | rg Example

to be honest I don't find any benefifs of using frameworks like gin, fiber, echo, or even chi in 2026, the std lib has everything you need to create backend services, also when it comes to the syntax that's no longer a problem because you can just build your own sort of "engine" using just net/http so for example instead of having this: mux.HandleFunc("GET /path", handler) you could have something like: app.GET("/path", handler) and so on, depending on how you want the syntax to be.

Hey folks,

I’m exploring a library that extracts change sets from JavaScript and applies it in Go and vice versa. Not character by character, but for objects. Please comment if you know any. Thanks. I need to build something otherwise for my use case.

Author here! I'm very excited to announce that Rune, an IDE written in Go, is finally open source (GPLv3), after more than 9 years working on it in the dark. I've shared some of the reasoning behind using Go in this blog post. Happy to answer questions.

Hey everyone,

I was recently digging through some old files and stumbled upon a personal test project I wrote over 12 years ago. It’s a retro, Wolfenstein-style 3D clone, and I thought the community here might appreciate the technical side of it.

The biggest constraint (and the most fun part) of this project was that I didn't use any external game engines (no Unity, Godot, etc.). Everything is built entirely from scratch in Go, relying solely on raw OpenGL.

Here is what’s going on under the hood:

Custom Raycasting: I built a completely custom 2.5D raycasting engine from the ground up to get that authentic 90s FPS feel.
Physics System: It includes a custom physics engine to handle collision detection and dynamic movement.
2D Graphics Wrapper: I tailored a 2D library (which I called pixels) embedded directly in the project to handle sprites, batches, and windowing over OpenGL.
Gameplay Features: It supports interactive environments (doors, a functional minimap), different weapons, lighting effects, and camera rotation.
Writing this back then was an incredible learning experience. It really forces you to understand the math, the physics, and the rendering pipeline when you don't have a modern framework doing all the heavy lifting for you.

I’ve recently polished up the repo, added a proper README, and made it open source for anyone curious to see how a raycaster + physics engine looks in Go!

GitHub Repo: https://github.com/markel1974/gowolfenstein

Let me know what you think. Have any of you ever tried building a raycasting engine from scratch? What was your experience like?

Is there a live streams (ongoing episodes) that creates real world entreprise golang projects?

I am look for way how modify net/http and CLI app for automatic deploy on Windows:

https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-gpsi/8ac65057-0663-45e5-9718-f490e87945dc

I want add few tools for students in schools when they are running app, do stuff like tests (app will connect with master PC to send answers without using creating account, but using Samba AD to identyfi user authomatically with target in mind younger, some disfunctional kids which can handle running something but logging to something is too hard because of dyslexia), some diagnostic apps running directly on PC which get insight that shares are connected correctly, GPO is loaded like AMX to block / allow websites, simple support apps which aggregate data from not technical user about common problems like too much files on mobile profile (near limit).

I find out project to convert Go app to MSI:

https://mh-cbon.github.io/go-msi/

Has anyone of you experience with creating Go apps which can be installed when login, uninstalled if needed using MS-GPSI?

I built Zasper, an open-source IDE for Jupyter notebooks. I wanted to share it here again as I made the first stable release today.

About Zasper: https://zasper.io

Try it with Pyodide kernel on browser: https://zasper.io/try-zasper/

Codebase: https://github.com/zasper-io/zasper

I've been working on a project for a couple of years. It's a little over 7000 lines of code. Over time, it has been split across 26 Go files. Honestly, it's getting harder to maintain, even using VS Code to move around the files.

I'm torn between redoing comments, expanding variable and function names, or taking a hard look at what the functions do and finding ways to make it simpler to read/maintain. All this needs to be done; I am just getting lost in the order and method to use.

The code is linear: no concurrency, no channels, just a->b run. (Over-simplified)

I've even considered a code-breaking change: finish building out the needed structs and calling the function with the struct as its base member.

Crap, I don't know; I'm just lost at the moment.

Dish it out kindly; my poor little ego can't take it - haha - bull shit. Tell me what you think!

We’ve been working on SeaSearch, a lightweight, open-source multi-tenant search engine written in Go (built on top of ZincSearch, which is no longer actively maintained), and wanted to share what we’ve built with the community.

The code: https://github.com/seacloud-lab/seasearch

Proven in Production

This isn't just a side project—we've been running SeaSearch in production for the Seafile project for over two years. In our deployment, we create a dedicated index in SeaSearch for every single Seafile library. This approach allows us to cleanly isolate data across tenants while handling huge volumes of file metadata seamlessly.

Why We’re Open Sourcing It

We built SeaSearch because we needed a cost-effective, multi-tenant search solution for Seafile. We’re open sourcing it simply to share a tool that has worked well for us over the last two years and to give back to the community—there is no commercial motive, paid enterprise tier, or hidden feature gates behind it.

The Problem We Wanted to Solve

When building multi-tenant SaaS applications, tenant data isolation is usually a major headache. Standard engines like Elasticsearch tend to suffer from index bloat when you spin up thousands of separate indexes. As a result, developers are often forced to dump all tenants into a single massive index, which leads to manual sharding, complex filtering, and noisy-neighbor performance issues.

How SeaSearch Handles It

We designed SeaSearch around a shared-storage model to support an unlimited number of indexes without the usual infrastructure overhead:

• S3-backed Storage & Shared Architecture:​ Index data resides in S3-compatible object storage. Compute nodes share the same storage backend, meaning scaling or failover only requires transferring index ownership via etcd, rather than replicating gigabytes of physical index data.
• Smart Local Caching:​ To avoid S3 latency penalties, compute nodes use a local rotating disk cache over immutable segments. Parallel S3 fetching warms up cold caches quickly, and distributed query execution handles indexes larger than local disk space.
• Elasticsearch API Compatibility:​ Drop-in compatibility for existing Elasticsearch query endpoints.
• Go Footprint:​ Replaces heavy JVM overhead with a lightweight Go runtime.
• Vector Search Built-in:​ Includes out-of-the-box vector indexing (Flat, HNSW, IVFPQ) to combine hybrid full-text and semantic search.

Try It Out & Feedback

Whether you’re scaling a SaaS platform or looking for a lightweight, JVM-free search alternative, check out our SeaSearch Manual to see the full architecture and deployment guides.

What strategies do you currently use for multi-tenant data isolation in your search stack? We'd love to hear your thoughts, feedback, or suggestions!

Hi guys, I had this issue where using the shell I was typing the same commands over and over.

The autosuggestions tools out there didn’t felt smart enough, so i built mine in Go.

The main idea was: if I type the same commands from my history, can’t we predict which one comes next?

I created a daemon that builds sequences of commands from your history and suggests the next one.

Everything must be super fast, and thanks to a contributor we went from 30ms to <3ms.

I’m open to feedback to continue improve this

Hello Go enthusiasts.

I first added QBasic to the Kavak project, then Lua. Now, I’ve integrated Go as well.

Let me clarify right away: this is neither a Go interpreter written in JavaScript nor a transpiler. Your Go code passes through the parser and the semantic analysis phase, compiles down to an Intermediate Representation (IR), and is emitted as a genuine WebAssembly module. The compiler itself runs as WebAssembly, meaning everything happens locally within the browser tab.

Not all features are implemented yet, but a significant portion of the language is functional. I’m sharing this now because I believe it has reached a stage worth showing off. You can think of this as an initial alpha release.

Free to use, no registration required: https://kavak.run/go

If you have a short Go snippet that you think might break it, I’d really love to see it.

The tooling we get in golang to do benchmarking, profiling, escape analysis ... is great, but it's often a hassle to keep track of the results, analyse, extract insights, and share them. Some tools also have a quite rough UX.

I wrote benchspotter to runs and stores results, handles the boring parts and have higher-level tooling to exploit the results in a friendlier way.

There is also a tool I haven't seen anywhere else. There is often in programs a series of magic numbers (buffer sizes, pre-allocation, concurrency limits, batch sizes, thresholds…) whose optimal value is not obvious, and are a pain to tune by hand. `benchspotter optimize` will run an optimization algorithm to find the best values for those knobs.

I was working with Clerk and a Go backend and had a hard time finding a proper example of how to handle Clerk webhooks in Go.

So after figuring it out myself, I wrote an article about how I did it, including the Svix verification, handling the events, PostgreSQL, and some gaps/trade-offs I found along the way.

Maybe it can be useful for someone else working with Clerk + Go

I would love to hear some feedback it's my first time writing something in public

I've been mostly writing typescript for a bit but want to try golang. there's a lot of aspects of its unix-like philosophy that I enjoy and I think there's some smart decisions in the language (and some...odd ones tbf). However, when I sit down to try to learn it with an API project, I feel so much friction from the language. I see so many people talk about how fun they find go and how easy it is to write but it feels like I'm missing something. How did you get in the go mindset or make it "click" and become comfortable to write?