kolkov

hace 20 díasdiscuss

[flagged]

hace 2 mesesdiscuss

https://github.com/born-ml/born --- Production-ready ML framework for Go with zero dependencies. Train and deploy neural networks as single binaries. PyTorch-like API, type-safe tensors, automatic differentiation.

kolkov

hace 2 mesesdiscuss

https://github.com/gogpu --- Pure Go GPU Computing Ecosystem — Graphics, Shaders, ML, GUI. Zero CGO.

kolkov

hace 3 mesesdiscuss

How many not-so-smart and not-so-intelligent people can claim Russia occupied you? Never mind, your liberation by the West will come back to haunt you, mark my words... and very soon! You'll remember how well you lived during the years of the USSR and the Warsaw Pact!

kolkov

hace 3 mesesdiscuss

I write it myself, the agent only translates it into English.

kolkov

hace 3 mesesdiscuss

"Prompt injection from the issue?" — That's the best theory so far

kolkov

hace 3 mesesdiscuss

"Is the Claude thank you sarcasm?" — Mostly. But the sequence is real: we filed #39755 asking for source access on March 27, the source map shipped on March 31. The actual explanation is simpler — Bun generates source maps by default, and nobody checked the build output. Which is itself the point: 64K lines of code with no build verification process.

kolkov

hace 3 mesesdiscuss

[dead]

kolkov

hace 3 mesesdiscuss

"Why would you ship tests?" — Fair point. Source maps only include production bundle files — tests wouldn't appear in the map regardless. Tests may well exist in Anthropic's internal repo, and we can't claim otherwise. However, the bugs we found speak for themselves: a watchdog that doesn't protect the most vulnerable code path for 5+ months, a fallback with telemetry that never executes where it's needed, Promise.race without catch silently dropping tool results. If tests exist, they clearly don't cover the streaming pipeline adequately — these are the kind of issues that even basic integration tests would catch.

kolkov

hace 3 mesesdiscuss

[dead]

kolkov

hace 3 mesesdiscuss

[flagged]

kolkov

hace 4 mesesdiscuss

Hi HN! Author here.

Some of you may remember the purego discussion from 2023 (https://news.ycombinator.com/item?id=34763681, 268 points). It proved that calling C from Go without CGO is viable. We built on that foundation.

Why another FFI library?

We needed to call wgpu-native (WebGPU) from Go — thousands of FFI calls per frame. purego's reflect-based dispatch (RegisterFunc → reflect.MakeFunc → sync.Pool per call) was too much overhead for our use case. We also needed struct passing by value and callback float returns, which purego doesn't support.

So we took a libffi-style approach:

  cif := &types.CallInterface{}
  ffi.PrepareCallInterface(cif, types.DefaultCall, retType, argTypes)  // once
  ffi.CallFunction(cif, fnPtr, &result, args)                         // many times, zero alloc

Type classification is pre-computed at prepare time, not at call time. The call path is: Go → runtime.cgocall → hand-written asm → C function. The asm loads GP/FP registers per ABI from a flat argument buffer — no interpretation at call time.

The assembly:

Three hand-written stubs: System V AMD64 (RDI,RSI,RDX,RCX,R8,R9 + XMM0-7), Win64 (RCX,RDX,R8,R9 + XMM0-3, 32-byte shadow), AAPCS64 (X0-X7, D0-D7, HFA support). Each is ~100 lines of Plan 9 asm.

What goffi does that purego doesn't:

Struct passing by value (8B in RAX, 9-16B in RAX+RDX, >16B via sret pointer). Callback float returns via XMM0 — purego panics on float/double return from callbacks. Typed errors — 5 error types with errors.As() instead of generic errors. Context support for timeouts and cancellation.

What purego does better (being honest):

purego supports 8 GOARCHes and 20+ OS×ARCH combinations — we cover 6 targets (amd64×4 + arm64×2). purego auto-marshals strings, bools, and slices — we work with raw unsafe.Pointer. purego has a much simpler API — one line to bind a function. purego has full Darwin ARM64 variadic stack packing — we don't yet.

Related projects worth knowing:

JupiterRider/ffi (https://github.com/JupiterRider/ffi) — pure Go binding for native libffi via purego. Supports variadic and struct pass/return, but requires libffi.so at runtime. If you need variadic calls today, that's a good option.

Where we use it:

goffi powers gogpu (https://github.com/gogpu) — a pure Go GPU computing platform with WebGPU bindings, zero CGO. It's also used in Born (https://github.com/born-ml/born) — an ML framework for Go with PyTorch-like API, type-safe tensors, and automatic differentiation. Both projects ship as single binaries with no C toolchain required. 89% test coverage, CI on Linux/Windows/macOS, MIT license.

We wrote a deep dive on the architecture, assembly, and callback mechanism: https://dev.to/kolkov/goffi-zero-cgo-foreign-function-interf...

Happy to discuss FFI internals, ABI details, or the trade-offs between the different approaches!

kolkov

hace 5 mesesdiscuss

Author here. I've been practicing what Karpathy now calls "Agentic Engineering" since January 2026 – a month before he coined the term. Across 35+ open source Go projects (~1M+ LOC total, including a 425K LOC pure Go GPU ecosystem), I found that orchestrating agents isn't enough. The critical missing piece is what I call Bidirectional Learning: structured knowledge files that the AI reads on session start and updates on exit. Each session compounds on the last instead of starting from zero. Without this, you're conducting an orchestra that forgets the piece they played yesterday.

Happy to answer questions about the workflow or any of the projects.

Submissions

[untitled]

[untitled]

[untitled]

[untitled]

[untitled]

[untitled]

[untitled]

[untitled]

Goffi – Pure Go FFI with hand-written assembly for System V, Win64, ARM64

[untitled]

[untitled]

comments