frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

Start all of your commands with a comma (2009)

https://rhodesmill.org/brandon/2009/commands-with-comma/
254•theblazehen•2d ago•85 comments

Hoot: Scheme on WebAssembly

https://www.spritely.institute/hoot/
26•AlexeyBrin•1h ago•2 comments

OpenCiv3: Open-source, cross-platform reimagining of Civilization III

https://openciv3.org/
706•klaussilveira•15h ago•206 comments

The Waymo World Model

https://waymo.com/blog/2026/02/the-waymo-world-model-a-new-frontier-for-autonomous-driving-simula...
969•xnx•21h ago•558 comments

Vocal Guide – belt sing without killing yourself

https://jesperordrup.github.io/vocal-guide/
68•jesperordrup•6h ago•31 comments

Reinforcement Learning from Human Feedback

https://arxiv.org/abs/2504.12501
7•onurkanbkrc•46m ago•0 comments

Making geo joins faster with H3 indexes

https://floedb.ai/blog/how-we-made-geo-joins-400-faster-with-h3-indexes
135•matheusalmeida•2d ago•35 comments

Where did all the starships go?

https://www.datawrapper.de/blog/science-fiction-decline
45•speckx•4d ago•35 comments

Unseen Footage of Atari Battlezone Arcade Cabinet Production

https://arcadeblogger.com/2026/02/02/unseen-footage-of-atari-battlezone-cabinet-production/
68•videotopia•4d ago•7 comments

Jeffrey Snover: "Welcome to the Room"

https://www.jsnover.com/blog/2026/02/01/welcome-to-the-room/
39•kaonwarb•3d ago•30 comments

ga68, the GNU Algol 68 Compiler – FOSDEM 2026 [video]

https://fosdem.org/2026/schedule/event/PEXRTN-ga68-intro/
13•matt_d•3d ago•2 comments

What Is Ruliology?

https://writings.stephenwolfram.com/2026/01/what-is-ruliology/
45•helloplanets•4d ago•46 comments

Show HN: Look Ma, No Linux: Shell, App Installer, Vi, Cc on ESP32-S3 / BreezyBox

https://github.com/valdanylchuk/breezydemo
239•isitcontent•16h ago•26 comments

Monty: A minimal, secure Python interpreter written in Rust for use by AI

https://github.com/pydantic/monty
237•dmpetrov•16h ago•126 comments

Show HN: I spent 4 years building a UI design tool with only the features I use

https://vecti.com
340•vecti•18h ago•147 comments

Hackers (1995) Animated Experience

https://hackers-1995.vercel.app/
506•todsacerdoti•23h ago•247 comments

Sheldon Brown's Bicycle Technical Info

https://www.sheldonbrown.com/
389•ostacke•21h ago•98 comments

Show HN: If you lose your memory, how to regain access to your computer?

https://eljojo.github.io/rememory/
303•eljojo•18h ago•188 comments

Microsoft open-sources LiteBox, a security-focused library OS

https://github.com/microsoft/litebox
361•aktau•22h ago•186 comments

An Update on Heroku

https://www.heroku.com/blog/an-update-on-heroku/
428•lstoll•22h ago•284 comments

Cross-Region MSK Replication: K2K vs. MirrorMaker2

https://medium.com/lensesio/cross-region-msk-replication-a-comprehensive-performance-comparison-o...
3•andmarios•4d ago•1 comments

PC Floppy Copy Protection: Vault Prolok

https://martypc.blogspot.com/2024/09/pc-floppy-copy-protection-vault-prolok.html
71•kmm•5d ago•10 comments

Was Benoit Mandelbrot a hedgehog or a fox?

https://arxiv.org/abs/2602.01122
23•bikenaga•3d ago•11 comments

Dark Alley Mathematics

https://blog.szczepan.org/blog/three-points/
96•quibono•4d ago•22 comments

The AI boom is causing shortages everywhere else

https://www.washingtonpost.com/technology/2026/02/07/ai-spending-economy-shortages/
26•1vuio0pswjnm7•2h ago•17 comments

How to effectively write quality code with AI

https://heidenstedt.org/posts/2026/how-to-effectively-write-quality-code-with-ai/
271•i5heu•18h ago•219 comments

Delimited Continuations vs. Lwt for Threads

https://mirageos.org/blog/delimcc-vs-lwt
34•romes•4d ago•3 comments

I now assume that all ads on Apple news are scams

https://kirkville.com/i-now-assume-that-all-ads-on-apple-news-are-scams/
1079•cdrnsf•1d ago•461 comments

Introducing the Developer Knowledge API and MCP Server

https://developers.googleblog.com/introducing-the-developer-knowledge-api-and-mcp-server/
64•gfortaine•13h ago•30 comments

Understanding Neural Network, Visually

https://visualrambling.space/neural-network/
306•surprisetalk•3d ago•44 comments
Open in hackernews

Bazel and Glibc Versions

https://blogsystem5.substack.com/p/glibc-versions-bazel
27•goranmoomin•4mo ago

Comments

shykes•4mo ago
It appears the Bazel community is getting closer to inventing containers.
jeffbee•4mo ago
Bazel comes with ironclad sandboxing features, but people don't use them because build correctness is such a chore.
paulddraper•4mo ago
Bazel has number of strategies, including containers.

But that’s only a minority of what it does.

klodolph•4mo ago
I don’t think there’s any real insights there.

Containers tend to be coarse-grained. For example, maybe you are writing a program, so you put the entire build environment in a container. If you have lots of programs with different dependencies, do you need lots of containers? Do you need to rebuild lots of containers when dependencies change? Bazel is much more fine-grained, and in Bazel, each individual build action gets its own build environment.

By default, that build environment includes the host (build system) glibc, compiler, system headers, system libraries, etc. If you want repeatable builds, you turn that off, and give Bazel the exact glibc, compiler, libraries, etc. to use for building your program.

You get the isolation of containers, but much faster builds and better caching.

josephg•4mo ago
You don’t need containers. Just hermetic builds. Ideally every byte read during the compilation process comes from a file under your control, that you version and you test. That includes the compiler, glibc, and all of your dependencies.

Ambient, implicit dependencies are the devil’s playthings.

shykes•4mo ago
Right. But you need tooling to manage those dependencies, and an ecosystem of content to avoid reinventing the wheel. That's what containers provide. Since Bazel predates the modern container ecosystem, it had to invent its own tooling. The user experience is very rough, and the ecosystem tiny. As a result most Bazel users do not run their builds in a controlled environment - see the parent blog post.

Adopting containers would solve this, but it seems to be a major blind spot for the Bazel community. My theory is that for them to adopt container technology, they will have to reinvent it themselves, hence my tongue-in-cheek comment.

fooblaster•4mo ago
Why ain't the first answer.. use a bazel provided tool chain instead of using system toolchains? This article is totally mad.
jmmv•4mo ago
Because those Bazel toolchains don’t come with a glibc? How could they?
lokar•4mo ago
What? Of course they can, how is that hard?
jmmv•4mo ago
You need that glibc on the target system, and glibc doesn’t like static linking. How do you ship the built binary?
lokar•4mo ago
You include the target glibc as part of your toolchain

And, I always prefer to actually pick my glibc independently from the host os and ship it with the binary (generally in an OCI image). This way you can patch/update the host without breaking the service.

remexre•4mo ago
Does that result in working NSS?
lokar•4mo ago
I normally statically link as much as possible and avoid nss, but you can make that work as well, just include it along with glibc.
jmmv•4mo ago
Right, so you need to end up creating a container to package the glibc with the binary. Which is not very different from having sysroots.

But what about any tools compiled from source and used during the build? Those can also suffer from these issues.

lokar•4mo ago
Yeah, ideally you could build your toolchain from source on any platform. But, in some cases that’s not possible
prpl•4mo ago
no, you just need a compatible starlit/glibc. you pick an old version (e.g. RHEL8) or otherwise compile with multiple tool chains if you need newer glibc features
throwaway2046•4mo ago
Is musl not an option? It's best to avoid glibc altogether if possible.
steeve•4mo ago
This one does, we use it with great success: https://github.com/cerisier/toolchains_llvm_bootstrapped
lokar•4mo ago
Yeah, making the entire tool chain hermetic and versioned is one of the main benefits of bazel.

You can have every developer cross-compile from a different os/cpu platform

paulddraper•4mo ago
Agreed.
jeffbee•4mo ago
You make it sound simple. Bazel's docs are minimal and what exists is often wrong. For a C or C++ toolchain you might turn to a contributing project such as toolchains_llvm, but even those experts are still figuring it out, and they give you little guidance on how to assemble your sysroot, which is the actual issue in the article. And, the upstream distributions of LLVM are built under certain assumptions, so unless you know exactly what you are doing, you probably also want to build LLVM instead of using their archives. If you figure out how to build LLVM in a completely consistent and correct way with respect to the STL and support libraries, you will be perhaps the 3rd or 4th person in history to achieve it.
prpl•4mo ago
llvm_toolchain or gcc-toolchain or the uber one are all some possibilities
steeve•4mo ago
Yes: https://github.com/cerisier/toolchains_llvm_bootstrapped
notpushkin•4mo ago
> the service crashes with a mysterious error: version 'GLIBC_2.28' not found

Mysterious?

This is by the way why many binary Python packages use https://github.com/pypa/manylinux for builds: if you build on an old glibc, your library will still (generally) work with newer versions.

10000truths•4mo ago
One of the niceties of Zig's build system is its batteries-included support for targeting an explicitly provided glibc version. No need for alternate sysroots or dedicated old-distro containers like you would with the traditional C/C++ compilers, all you have to do is append it to the target triplet, like so:

zig cc -target x86_64-linux-gnu.2.17 file.c

klodolph•4mo ago
It’s not hard in Bazel either, it’s just not batteries-included.
klodolph•4mo ago
JFC the author has done everything wrong here.

A heterogenous build cluster with non-hermetic builds and shared caching. The fact that this is only a glibc symbol versioning problem and not something far more severe is, well, a blessing.

At the bare fucking minimum, I would expect the CI builds to have a homogenous configuration and their own cache, not writable from outside CI. If you’re lazy, just wipe the cache every time you upgrade the CI cluster. Maybe I’ve just been living too long in environments where we care about artifact provenance and I’m blind to the whims of people who don’t care about provenance.

I want to feel sympathetic, because I know Bazel is a pain in the ass to learn, but it sounds like the author was juggling knives in a windstorm and caught a few pointy ends.

r2vcap•4mo ago
Whether you use Bazel or not, this is a well-known issue with an equally well-known solution. There’s no need for such a lengthy write-up: just use a consistent sysroot across your entire build environment.

If you can’t create your own sysroot image, you can simply download Chromium’s prebuilt one and configure your C++ compile rules correctly. Problem solved.

01HNNWZ0MV43FF•4mo ago
Sounds like a jerb for Docker
rockwotj•4mo ago
Yeah I built a custom sysroot for Redpanda (Bazel/C++/Distributed Kafka) using a really simple docker image: https://github.com/redpanda-data/redpanda/blob/dev/bazel/too...

We also have an dockerfile for clang/LLVM in that repo so the whole thing is hermetic. It’s a bit of shame Bazel doesn’t come with stronger options/defaults here, because I feel like I want to reproduce this same toolchain on every C++ project with Bazel

DriftRegion•4mo ago
Thanks for sharing. As a non-google bazel user this is quite helpful.
cryptonector•4mo ago
This happens in CIs. It's happened to me on GitHub Actions. The answer is always sysroots.
Arrowmaster•4mo ago
I'm in the middle of submitting PRs to multiple projects because they are compiling on ubuntu-latest and forcing a glibc 2.38 requirement. These are multiplatform projects where most or none of the devs use Linux.

The first project I was able to change their workflow to build inside a 20.04 container. The other project uses tauri and it requires some very recent libraries so I don't know if an older container will work.

Do you have any documentation or generic recommendations for solving these issues caused by blindly using GitHub Actions for all compilations?

cryptonector•4mo ago
> The first project I was able to change their workflow to build inside a 20.04 container.

This approach does _not_ work because you end up with the `node` that runs GitHub Actions not being able to run, certainly this will happen if you end using a sufficiently old container.

> Do you have any documentation or generic recommendations for solving these issues caused by blindly using GitHub Actions for all compilations?

Install these pkgs in an `ubuntu-latest` image:

  - debootstrap debian-archive-keyring
  - software-properties-common
  - schroot fakeroot fakechroot
then

      - name: 'Cache sysroot'
        # This comes after checking out the sources because
        # actions/checkout@v4 cleans $PWD!
        id: cache-sysroot
        uses: actions/cache@v3
        with:
          path: ${{ github.workspace }}/sysroot-DEBIAN_RELEASE
          key: sysroot-DEBIAN_RELEASE-${{ runner.os }}-${{ runner.arch }}-v1

      - name: 'Setup cross-compilation sysroot'
        if: steps.cache-sysroot.oututs.cache-hit != 'true'
        run: |
          set -vx
          SYSROOT_PATH="${{ github.workspace }}/sysroot-DEBIAN_RELEASE"
          echo "SYSROOT_PATH=$SYSROOT_PATH" >> $GITHUB_ENV
          if [ ! -d sysroot-DEBIAN_RELEASE ]; then
            sudo debootstrap --arch=$(dpkg --print-architecture) DEBIAN_RELEASE sysroot-DEBIAN_RELEASE http://archive.ubuntu.com/ubuntu
          fi
          sudo chroot sysroot-DEBIAN_RELEASE apt-get update
          sudo chroot sysroot-DEBIAN_RELEASE apt-get install -y build-essential git wget curl sudo unzip zip autoconf libfreetype6-dev libcups2-dev libx11-dev libxext-dev libxrender-dev libxrandr-dev libxtst-dev libxt-dev libasound2-dev libffi-dev file binutils libfontconfig-dev
          sudo chroot sysroot-DEBIAN_RELEASE apt-get install -y software-properties-common
          sudo chroot sysroot-DEBIAN_RELEASE sudo add-apt-repository ppa:ubuntu-toolchain-r/test
          sudo chown -R $USER:$USER sysroot-DEBIAN_RELEASE
where you replace `DEBIAN_RELEASE` with the release you want to target, and then

  - configure your project's build to use that sysroot.
That's it.

If your project does not support sysroots, make it do so. In general compilers will support sysroots, so it's just a matter of making your build configuration facility support sysroots.

setheron•4mo ago
Am I the first to say "Nix solves this" Nix effectively ships a sysroot with every binary !
steeve•4mo ago
This sandboxed LLVM toolchain completely solves that problem: https://github.com/cerisier/toolchains_llvm_bootstrapped
shaftway•4mo ago
> The CI system picks it up, gets a cache hit from the developer’s build, and produces a release artifact.

Why would you cache developer builds on CI?