HNHacker News
TopNewBestAskShowJobs

kylegalbraith

574 karma · joined September 6, 2017

Founder of https://depot.dev/

Blog at https://blog.kylegalbraith.com

Previously at: Era Software, Thorn, Zapproved

Previously built: https://ultimatefantasysupercross.com/ https://kylegalbraith.com/learn-aws/ https://kylegalbraith.com/learn-by-doing/

kyle@depot.dev

submissionscomments
kylegalbraith··on Show HN: Next-token prediction in JavaScript
This is what HN is all about. This probably isn't your next big LLM project but its a wonderfully simple example that shows what is happening underneath the hood. Do you plan on writing up something like a blog post to go with it?
kylegalbraith··on Show HN: Shorebird 1.0, Flutter Code Push
Just curious if you thought of other build systems outside of Bazel and if so which ones & why?
kylegalbraith··on Cache is King: A guide for Docker layer caching in GitHub Actions
Yup! We observed the same thing back before we built Depot. The act of saving/loading cache over a GHA network pretty much negated any performance gain from layer caching. So, we created a solution to persist cache to NVMe disks and orchestrate that across builds so it's immediately available on the next build. All the performance of layer caching without any network transfer.

The registry cache idea is a neat idea, but in practice suffers the same problem.

kylegalbraith··on Cache is King: A guide for Docker layer caching in GitHub Actions
Couldn't agree more. Somewhere, we lost the concept of disks in CI unless you run it yourself, and a lot of build tools could benefit from having them.

We came to the same conclusion and built Depot around this exact workflow for the Docker image build problem. We're now bringing that same tech into GitHub Actions workflows.

kylegalbraith··on Cache is King: A guide for Docker layer caching in GitHub Actions
This is definitely a direction to try. But if its faster Docker image builds and a layer caching system that actually works, you should definitely try out Depot. We automatically persist layer cache to persistent NVMe devices and orchestrate that to be immediately available across builds.
kylegalbraith··on Cache is King: A guide for Docker layer caching in GitHub Actions
Thanks for the shout-out regarding Depot, really appreciate it. We came to the same conclusion regarding Docker layer cache and thus why we created Depot in the first place. The limitations and performance surrounding GitHub Actions cache leaves a lot to be desired.
kylegalbraith··on Show HN: Managed GitHub Actions Runners for AWS
Other Depot founder here. This is a really great point.

You've hit on all the main points regarding Docker image cache in GHA. Persisting the massive layer cache over networks is incredibly slow and has weird limits (like 10GB per repo). We persist the layer cache to ceph volumes and orchestrate your cache so it's immediately available across builds with our first service, accelerated container image builds. Our GHA runners run right next to that same infra, so you don't have ingress/egress. All that can be hosted in your own AWS account (we're also open to running that in any general compute environment for folks who need it).

kylegalbraith··on Show HN: OneUptime – open-source Datadog Alternative
Do you not offer Arm images for the various services? For folks wanting to run this stack, I'd imagine some of them are interested in running on Arm for better cost optimization. Maybe it doesn't matter for how lightweight the services may be.
kylegalbraith··on Show HN: deptry 0.14.0 – detect unused Python dependencies up to 10 times faster
Does this work with uv as well?
kylegalbraith··on Show HN: I made a free animator. Think Adobe Illustrator but for animation
This is super cool and was very easy to get going. Missing keyboard shortcuts is pretty annoying and would make this even simpler. I hopped in hoping it was like a Google Drawing, which it's pretty close, but the lack of keyboard shortcuts for copying/pasting, selecting all, etc -- makes it hard to move fast.
kylegalbraith··on Carl Griffith's 1847 Oregon Trail Sourdough Starter
It's always a lot of fun to see stuff like this on HN. It's a reminder that there are still a lot of fun and amusing things on the internet.

I also love seeing stupid simple HTML sites like this. It's hideous to look at but it serves exactly the purpose it's there to do. It's also really fast.

kylegalbraith··on BuildKit in depth: Docker's build engine explained
Dagger is quite cool, and we've been doing some collaboration with their new Zenith stuff. We actually have a module where you can route an image build in your Dagger pipeline to Depot and do interesting things with the result as we stage your image in an ephemeral registry [0].

[0] https://github.com/depot/daggerverse/tree/main/depot

kylegalbraith··on BuildKit in depth: Docker's build engine explained
This is one of the things that led us to write this post! It's almost all undocumented, as you're mentioning, and there are quite a lot of complexities underneath the surface that often feel very inefficient as well.

We're working on another project in this realm that might interest you. Happy to send over more details via email if your interested in better build APIs. My contact info is in my profile.

kylegalbraith··on BuildKit in depth: Docker's build engine explained
Not to shill another blog post of ours in here, but maybe this is helpful.

It's not exactly what you're asking for as it relates to running containers via runc. But this walks through how OCI layers are actually built up behind the scenes. In case it's helpful: https://depot.dev/blog/building-container-layers-from-scratc...

kylegalbraith··on BuildKit in depth: Docker's build engine explained
Hey, thanks for the question! Depot co-founder here.

We've optimized BuildKit for remote container builds with Depot. So we've added things like a different `--load` for pulling the image back that is optimized to only pull the layers back that have actually changed between the build and what is on the client. We've also done things like automatically supporting eStargz, adding the ability to `--push` and `--load` at the same time, and the ability to push to multiple registries in parallel.

We've removed saving/loading layer cache over the network. Instead, the BuildKit builder is ephemeral, and we orchestrate the cache across builds by persisting the layer cache to Ceph and reattaching it on the next build.

The largest speedup with Depot is that we build on native CPUs so that you can avoid emulation. We run native Intel and Arm builders with 16 CPUs and 32GB of memory inside of AWS. We also have the ability to run these builders in your own cloud account with a self-hosted data plane.

So the bulk of the speed comes from persisting layer cache across builds with Ceph and native CPUs. The optimized portions of BuildKit really help post-build currently. That said, we are working on some things in the middle of the build related to the DAG structure of BuildKit that will also optimize up in front of the build.

kylegalbraith··on Show HN: Open-source x64 and Arm GitHub runners
Depot [0] founder here. Thanks for the mention. We're also planning on bringing a bit of a different take to GitHub Action runners that's not tied to Hetzner directly. It will be entirely open-source as well, so you can take it and run it on your own instances if you'd like. Similar to how Depot supports self-hosted builders in your own AWS account [1].

[0] https://depot.dev/

[1] https://depot.dev/docs/self-hosted/architecture

kylegalbraith··on Anki – Powerful, intelligent flash cards
Been using Anki for years for more advanced language learning. I usually keep notes of words or phrases that come up during my day to day living in France that are new to me (or used a way I’m less familiar with). I research their construction/uses and throw them in an ongoing study deck I review every morning.

It’s really helped me gain a deeper understanding of the language and feel more confident in conversations.

kylegalbraith··on Ceph: A Journey to 1 TiB/s
We started with AWS EBS volumes with BuildKit on EC2. We've now moved to BuildKit on EC2 and a Ceph storage cluster on bare metal EC2 instances.
kylegalbraith··on Ceph: A Journey to 1 TiB/s
This is a fascinating read. We run a Ceph storage cluster for persisting Docker layer cache [0]. We went from using EBS to Ceph and saw a massive difference in throughput. Went from a write throughput of 146 MB/s and 3,000 IOPS to 900 MB/s and 30,000 IOPS.

The best part is that it pretty much just works. Very little babysitting with the exception of the occasional fs trim or something.

It’s been a massive improvement for our caching system.

[0] https://depot.dev/blog/cache-v2-faster-builds

kylegalbraith··on Japan's Comfort Food: The Onigiri
This is the magical stuff that I love finding on HN. We don’t make this enough at home.
kylegalbraith··on Open Source Carta Alternative – Cap.octolane.com
I would probably change your site title :)

Cool idea. I'll be watching to see how it evolves.

kylegalbraith··on Dive: A tool for exploring a Docker image, layer contents and more
Dive is an amazing tool in the container/Docker space. It makes life so much easier to debug what is actually in your container. When we were first getting started with Depot [0], we often got asked how to reduce image size as well as make builds faster. So we wrote up a quick blog post that shows how to use Dive to help with that problem [1]. It might be a bit dated now, but in case it helps a future person.

Dive also inspired us to make it easier to surface what is actually in your build context, on every build. So we shipped that as a feature in Depot a few weeks back.

[0] https://depot.dev

[1] https://depot.dev/blog/reducing-image-size-with-dive

[2] https://depot.dev/blog/build-context

kylegalbraith··on AzuraCast: A Simple, Self-Hosted Web Radio Management Suite
I echo this sentiment. For the space this project is in, it's amazing the amount of support and coverage it gets from Buster & all the maintainers. This a good example of an open-source community done very well.
kylegalbraith··on Challenging projects every programmer should try (2019)
Total long shot. But does anyone have any good side projects that would center around simulating fluid dynamics? I’ve always been interested in aerodynamics and I’ve wanted to see if there is a way to learn more about it with my programming skills.
kylegalbraith··on Show HN: Go index me – Get your pages indexed by Google quickly
What does this get you that submitting a sitemap to Google doesn't?
kylegalbraith··on OpenTofu Release Candidate Is Out, GA Set for Jan 10th
Out of curiosity, is there any collection of folks that are actively moving to OpenTofu that have been waiting for a GA release?
kylegalbraith··on Show HN: WarpBuild – x86-64 and arm GitHub Action runners for 30% faster builds
We have this with https://depot.dev out of the box. You connect to a native BuildKit and run your Docker image build on native Intel and Arm CPUs with fast persistent SSD cache orchestrated across builds. It’s immediately there on the next build without having to save/load it over the network.
kylegalbraith··on Adding Build Provenance to Homebrew
What are some of the systems that make that difficult?
kylegalbraith··on Show HN: Dockerfile Explorer
Hey HN! We're excited to launch our Dockerfile Explorer. It allows you to visualize the lower level build ops (LLB)[0] that a Dockerfile is parsed to that BuildKit is parsed to. We built it to help people leveraging Depot get a better idea of what their Dockerfile is actually equating to at the LLB level.

LLB supports 6 core operations:

- SourceOp loads source files from a Docker image, git repo, or local build context (e.g. FROM) - ExecOp executes a given command (e.g. RUN) - FileOp creates, copies or removes files and directories (e.g. COPY, ADD, WORKDIR) - MergeOp merges its inputs into a single flat layer (e.g. COPY --link) - DiffOp produces an OCI diff, e.g. "layer", for its inputs (unused in the Dockerfile frontend) - BuildOp evaluates its input as additional LLB operations to add to the graph to allow for dynamic build graphs (also unused in the Dockerfile frontend)

With the Dockerfile Explorer, we run the Dockerfile frontend[1] that BuildKit uses inside of WASM to parse and produce the LLB output locally in your browser. We then embed the Monaco Editor so that you can change your Dockerfile to see how it impacts the LLB output that BuildKit will use to build your Docker image.

You can see a quick video and read more details on how it all works here: https://depot.dev/blog/dockerfile-explorer.

We'd love any feedback or ideas folks would like around this type of tool!

[0] https://github.com/moby/buildkit#exploring-llb [1] https://github.com/moby/buildkit/tree/master/frontend/docker...

kylegalbraith··on Hacking ADHD: Strategies for the modern developer
This was a very well written piece and really resonates with me.

I've never been diagnosed with ADHD but when I read pieces like this I always walk away feeling like I check most of the boxes. Has anyone ever encountered the same and been prompted to get help? Asking on HN probably isn't the best idea, but sometimes I really struggle with certain flows and the way others work that seems to run counter to my peak performance.

← PreviousPage 3 of 6Next →