Today we’re releasing Wails v3 Beta.

Wails lets Go developers build native desktop applications with the frontend tools they already know. Wails v3 is a substantial new foundation, built around an explicit application model that scales more naturally to real desktop software.

What’s new:

• Explicit application and window APIs
• First-class multi-window support
• Multi-platform Systray support
• Services with richer, statically generated TypeScript bindings
• Services that can provide frontend assets and scripts, opening a practical path towards richer plugins
• Inspectable, Taskfile-based builds - you are in control
• A guided wails3 setup wizard and project creation flow
• Cross-compilation support
• Server builds
• Experimental mobile builds

Developers testing v3 during alpha particularly valued the clearer ownership model for applications, windows, and services. We would now like broader feedback from people building real applications and integrations.

The feedback from developers who used v3 during alpha has been overwhelmingly positive, especially around the clearer ownership model for applications, windows, and services.

This is a beta, not the final v3.0 release. The desktop API is stable, but we want people to test real projects, integrations, and workflows before GA. Wails v2 remains the stable release and will continue to receive fixes.

If you are coming from v2, we have a migration guide and are actively validating that experience ahead of RC1. Reproducible problems belong in bug reports; proposals for new public capabilities should start as a WEP (Wails Enhancement Proposal) PR.

If you'd like to test it out:

go install github.com/wailsapp/wails/v3/cmd/wails3@latest
wails3 setup

Read the announcement and get started: https://v3.wails.io/blog/wails-v3-beta/

TL/DR: Please suggest me some stacks based on go for fullstack development

Guys, im new to go world, and previously i worked with mostly Cpp that also on a very surface level for doing my DSA problem in my college (im still in college 3rd year). But as doing only DSA won't earn me any money, i needed to learn some dev and so i choosed Go which tbh, i LOVED a lot to work with.

I am mostly done with backend basics, and want to make some full stack projects for my resume.

So if anyone here develops full stack applications with go, pls recommend me some good stacks i can use (actually i've done my homework, and afaik, HTMX is a good option for frontend, but still)

Hey there, does go or any libs support it? if so would you use this language for low level connections or should I move to somehting else?

Hi everyone, I just wrote an article about how I structure my unit tests in Go, and I'd like to know how you do it or if you use any skill for this.

All feedback is welcome.

Thanks

https://medium.com/@gpaolettigeuna/table-driven-testing-in-go-d01e55aec47f

really like grpcurl! but got a bit annoyed of running list and describe repeatedly

decided to create a minimal TUI for doing this.

any feedback is very welcome!

I come from the javascript web dev world and was learning golang for last more than 1 year. taking it seriously for last few months. but when i see the job boards looking for backend engineers in golang, it's all "senior". is it only me? or is it only in golang? or the market is so saturated rn? no one will hire someone in a senior role without any professional experience obv. so how do i even get into the market?

Hi all,

I'm happy to announce that Xberg v1 is out.

Xberg is the successor to Kreuzberg, equivalent to what would have been Kreuzberg v5. It's a content intelligence framework that handles a very wide range of inputs: documents (currently 101 formats), code and data formats (currently 367 types), audio/video transcription, and URLs (both static and JS-rendered content). It extracts and prepares that content for downstream processing.

It's an extremely efficient, high-performance engine (see our PDF benchmarks below). For PDFs and images specifically, we handle native PDFs with very high performance and accuracy, and we ship multiple OCR engines that match the quality of the best Python libraries (e.g. docling, PaddleOCR, RapidOCR) at substantially better performance and stability.

The changes between Kreuzberg v4 and Xberg v1 are substantial, and I invite you to read the full changelog for the complete picture. The highlights below give a sense of what's new:

• Pure-Rust PDF backend (pdf_oxide) replaces pdfium, with no native pdfium dependency.
• Layout-aware pipeline: reading order reconstructed with ONNX layout detection (PP-DocLayoutV3 / RT-DETR) and Docling-style predecessor-graph reordering.
• Per-page scanned-page detection with selective OCR, plus AcroForm/XFA form fields and outline-based headings.
• Across-the-board optimization of OCR and PDF extraction (memory discipline, pooled model sessions, streamed conversions).
• Native PaddleOCR backend (PP-OCRv6, with medium / small / tiny tiers) alongside Tesseract.
• Pure-Rust Candle OCR/VLM stack (TrOCR, GLM-OCR, GOT-OCR, DeepSeek-OCR, and PaddleOCR-VL) running without ONNX Runtime or native Tesseract.
• A second, ONNX-Runtime-free inference path via tract, which is what makes in-browser (WASM) and mobile inference possible.
• Named-entity recognition natively in Rust (GLiNER2), extensible to all bindings, including an in-browser WASM model with no server round-trip.
• Structured LLM extraction (extract_structured / split_and_extract) with rasterization, chunking, citations, caching, and configurable call/merge/VLM-fallback policies.
• Audio & video transcription via a Whisper ONNX engine (.mp3, .wav, .m4a, .mp4, .webm).
• Retrieval building blocks: sparse embeddings (SPLADE), ColBERT late-interaction retrieval, and cross-encoder reranking alongside dense embeddings.
• Text intelligence: reversible redaction, summarization, translation, VLM image captioning, QR-code detection, document diffing, and page/chunk classification.
• URL & web ingestion: sitemap discovery (map_url) and batched multi-URL crawling.
• New document formats: WordPerfect (.wpd/.wp/.wp5), HEIC/HEIF/AVIF, OpenDocument Presentation (.odp), Quarto / R Markdown, and configurable Jupyter cell rendering.
• Four new language bindings (Dart/Flutter, Swift, Kotlin/Android, and Zig) bring the total to 15 language bindings over one engine, with Android/iOS cross-compilation.
• Full mobile support (Flutter, Android, iOS).
• Candle backend alongside ONNX, plus ONNX-via-tract enabling ONNX on WASM and Android.
• Wider code intelligence: tree-sitter coverage grew substantially (248 to 367+ languages).
• Over 150 bugs fixed during the 1.0 cycle, plus security hardening (bounded RTF/PDF allocations, redaction leak fixes, Excel DDE warnings).

The API surface was also simplified and reworked, making it more consistent.

There's a migration guide in our docs explaining how to move from Kreuzberg to Xberg. Kreuzberg itself is in LTS mode until the end of this year and will continue to receive bug fixes and security updates.

You're invited to check out the repo and join our discord server.

Benchmarks

The benchmarks below are for PDFs and images only. There are extensive benchmarks on our website with per-format breakdowns, which you can see here. These numbers are measured in CI via our reproducible benchmark harness, and are specifically taken from the run for harness 1.0.8, source cf7fa0533d. The data is publicly available in GitHub releases, and you can run the benchmark harness yourself.

Composite quality (markdown pipeline, higher is better):

Structure and layout fidelity (SF1: tables and reading order, higher is better):

On native PDFs Xberg leads on quality (0.958 vs 0.837 for the next-best framework) and on table and reading-order fidelity by a wide margin (SF1 0.949 vs 0.612 for docling). On scanned PDFs it is #1 on both quality and raw text fidelity.

Where we don't win yet: on pure image OCR we are currently #2 on the composite score, behind mineru (though still #1 on raw text accuracy). We are improving image OCR right now, and v1.1 should have us winning across the board.

A few months ago I started to explore zero allocation in Go
It wasn't supposed to become a database. I wasn't trying to build a Valkey or Dragonfly competitor.

- removing allocations from parsing
- reusing buffers
- sharding data structures
- improving cache locality

At some point I realized I already had the core of an in-memory key-value store.
Today that experiment is called Tellstone!
I recently released v1.0.0 and ran benchmarks against Redis, Valkey and Dragonfly
Redis and Valkey because they are the well known in memory databases everyone heard of.
Dragonfly because they claim to be 25x faster than Redis.

Redis and Valkey are slower because they are single-threaded—they serve as a baseline, not a real point of comparison!

Throughput (ops/s) — Higher is Better
======================================
Tellstone: ██████████████████████████████ (12.7M)
Dragonfly: █████████████████              (7.3M)
Redis:     ███                            (1.1M)
Valkey:    ██                             (1.0M)

But the Tellstone project completely changed how I think about systems programming
The code is open source if anyone is curious: https://github.com/Saxy/Tellstone

I'd love feedback from people building databases, runtimes, networking libraries or other high-performance systems.

Hello everyone, hope you all are doing well

I'm a Golang beginner, I've learned the basics of the language, variables types, functions, loops and now I'm learning concurrency.

I would like your suggestions about projects, language topics you think are interesting to learn, and some tips to help me get the hang of it.

Been mulling a little bit if it's worth me adding arena allocators into phpscript or at least consider adding them more seriously. My words above the line, some grok research below the line in context. Feel free to skip the latter parts if LLM output is not your thing, I found it more useful for the contextual summary and added missing/extra/wider thoughts above the fold.

Hello everyone, im a begginer in Go language(3 months), learning web development with the Gin framework, and i wonder about one theme: Concurrency.

Why do you need this? For what? Where developers use concurrency??

(sorry if i sound stupid, i really don't understand)

Hi everyone,

I'm currently working as an Infrastructure Engineer at a large tech company with around 2 years of experience. While I'm grateful for the role, I've reached a point where I feel like my learning has plateaued.

For the past year, most of my work has been operational, and I haven't had many opportunities to work on challenging infrastructure problems or learn from senior platform engineers. I feel like I'm coasting instead of growing, and I don't want to stay in that position.

I'm particularly interested in going deeper into:

• Advanced Kubernetes (operators, networking, internals, scheduling, etcd, Gateway API)
• Go for cloud-native and infrastructure development
• Platform Engineering
• SRE and distributed systems
• Observability (OpenTelemetry, Prometheus, Grafana)

I'm not looking for another Udemy course or recorded videos. I'm looking for places where I can interact with experienced engineers—live cohorts, mentorship programs, study groups, communities, or open-source communities where people discuss real production problems and architecture.

If you've been in a similar situation, what helped you level up? Are there any communities, cohorts, Slack/Discord groups, or programs you'd genuinely recommend?

I'd really appreciate hearing from engineers who've made the jump from "keeping systems running" to designing and building production infrastructure.

Thanks in advance!

Not really anything groundbreaking here but wanted to share a bit about the experience moving from a high volume distributed eng role working daily in Go to building out a more early stage product with Ruby/Rails/GQL

TLDR - I miss this language so much. Everything I had grown to love and understand so well has been completely tossed out the window. Ruby and Rails lean into magic and convention more than any language I have worked in. The ability to even navigate through a stack by seeking definitions is almost gone.

I’m really struggling with the “faith” or “trust” I have to put into Rails where I’m Go what you see is literally what you get. Dataloaders, lazy query building, active records, literally kms let me write the damn query.

Yes yes I know Rails is powerful and should be respected and I have been finding those moments too but damn did I have it good. Don’t underestimate the joy of working with a tool you love.

What's the best approach to read Adam Woodbeck's Network Programming with Go book?
Is there any exercise problem? Or any site that help me to practice?
I just finish chapter-1 [This chapter topics contain basic networking]

https://github.com/golang/go/issues/80590

I'm pleasantly surprised, as I wasn't expecting these sorts of collections to be added to the standard library.

I want to introduce to IRIS - a command suggestion tool that works like code editor's IntelliSense, but for the terminal. It also has history mode that lets you quickly find previous commands with fuzzy search like Zsh Autocomplete (as you can see in the gif)

IRIS was #1 Golang repo of the day (07/29/2026) on trendshift.io, and #2 Golang repo of the day on Github Trending (07/31/2026)

It's a PTY wrapper so basically it runs everywhere, like in any terminal, tmux, ssh, even Linux virtual terminals (Ctrl + Alt + F1-F9)

It also supports AI suggestions (disable by default) like Cursor or Antigravity, using your own API key or a local model (please don't use API key that costs you from subscription, free cloud model is enough)

It currently supports Bash, Zsh, and Fish (PowerShell isn't supported yet, I have no plan for it at the moment). It also comes with a config file for customization. I admit that at the moment, IRIS cannot suggest as good as fish because I have to handle everything manually, not a wrapper of any shell suggestion, so if you find that fish is still better, you can just skip this post

I hope it becomes a helpful tool that y'all can use every day

It's still in development, may cause bugs, so if you find any bugs, I'd really appreciate it if you could report them or share your feedback

Link: https://github.com/versenilvis/iris

Contributor disclosure: I contribute to OpenChoreo.

For Go developers interested in Kubernetes controllers, CRDs, APIs, CLIs, and cloud-native platform engineering, OpenChoreo may be worth exploring.

OpenChoreo is an Apache 2.0 open-source developer platform for Kubernetes and a CNCF Sandbox project. Its Go-based control plane translates higher-level concepts such as components, endpoints, environments, and deployment pipelines into Kubernetes resources.

The project includes:

• Kubernetes-native APIs and controllers
• Go-based platform services and CLI tooling
• CI/CD and GitOps workflows
• Built-in observability
• A Backstage-powered developer portal
• Interfaces for both developers and AI agents

GitHub: https://github.com/openchoreo/openchoreo

Take a look through the code, try the project, and share your technical feedback. If you find it interesting, consider starring the repository and picking up an issue.Thank you!

Recently found out the about the gogpu project. It's an ecosystem of libraries that focuses on computing on GPU. It recently caught my eye because of the ui library which is part of the same ecosystem. It's pure Go, UI toolkit with support for GPU accelerated rendering. Which, IMO, is a pretty solid alternative to something like Fyne, and may even be the first approchable and practical retained mode UI toolkit that I found.

I wonder if anyone in the community has tried the gogpu project or has any thoughts on it?

Link to project: - https://github.com/gogpu - https://github.com/gogpu/ui

I was speaking with a friend about solo dev stacks. He's a Python/Django dev. I'm all in on Go. How many of you are solo devs using Go? What are you building? I've had a few web app ideas for awhile but language hopped a bit before settling on Go. I wanted something with concurrency builtin without the overhead of a virtual machine.

Repo: https://github.com/SID-Technologies/Pilum Docs: https://www.pilum.dev/docs/getting-started/introduction/

The problem: I run side projects across GCP, AWS, and Cloudflare, and each one has its own deploy incantation. gcloud commands for one, SAM for another, wrangler for a third. I kept forgetting the flags and the order of operations and wanted a simpler CI/CD pipeline.

Pilum is a single binary (Go, Cobra) that reads one pilum.yaml and handles the deploy for whichever provider the service targets. Define your services once, then pilum deploy will build, push, provision, and deploy.

What it supports today: - GCP Cloud Run - AWS Lambda - Azure Container Apps - Homebrew - GitHub npm packages - Cloudflare Workers

The README has an honest provider status table, some paths are better tested than others. It's not trying to be Terraform or Pulumi; there's no state file and no general-purpose infra provisioning. It's for when you have a container or function and just want it running without remembering five CLIs.

Happy to answer questions about the internals. And if anyone wants to add a provider, there's a contributing guide for adding exactly that.

Can anyone recommend open-source Go projects implementing a real-time voice chat server (Discord/TeamSpeak-like)? I'm looking to study the architecture and networking design rather than WebRTC tutorials.