Show stories

Hello,

I would like to share a Rust implementation of the Zstandard seekable format I've been working on.

Regular zstd compressed files consist of a single frame, meaning you have to start decompression at the beginning. The seekable format splits compressed data into a series of independent frames, each compressed individually, so that decompression of a section in the middle of an archive only requires zstd to decompress at most a frame's worth of extra data, instead of the entire archive.

I started working with the seekable format because I wanted to resume downloads of big zstd compressed files that are decompressed and written to disk on the fly. At first I created and used bindings to the C functions that are available upstream[1], however, I stumbled over the first segfault rather quickly (it's now fixed) and found out that the functions only allow basic things. After looking closer at the upstream implementation, I noticed that is uses functions of the core API that are now deprecated and it doesn't allow access to low-level (de)compression contexts. To me it looks like a PoC/demo implementation that isn't maintained the same way as the zstd core API, probably that's also the reason it's in the contrib directory.

My use-case seemed to require a complete rewrite of the seekable format, so I decided to implement it from scratch in Rust using bindings to the advanced zstd compression API, available from zstd 1.4.0.

The result is a single dependency library crate[2], and a CLI crate[3] for the seekable format that feels similar to the regular zstd tool.

Any feedback is highly appreciated!

[1]: https://github.com/facebook/zstd/tree/dev/contrib/seekable_f... [2]: https://crates.io/crates/zeekstd [3]: https://github.com/rorosen/zeekstd/tree/main/cli

I've always found it cool to be in roles where I can help a younger generation learn skills to have a bright future. That role is something I do in a few ways (as a parent, robotics mentor, school board advisor and Sunday school teacher) and I suspect most HN readers share the same role and appreciation. And for developing software skills, it was obvious that both the students and I had to have a productive software environment where we could work together. That theme of experienced/inexperienced engineers working together is the context in which I created `dk` as a scripting tool.

My testing ground has been students with one or two AP CS courses (high school computer science in the US), some of whom interned with me. I had to tackle a few problems:

- The development environment had to be simple to setup and the programming language couldn't be complicated - The recognition that writing small, easily testable units of work (ex. "scripts") has been the only way I've found for very junior programmers to develop a large application - Cheap, locked-down development hardware (ex. school computers with limited RAM and no Administrator privileges) is sometimes used for deployment to cheap hardware targets (ex. hand-me-down Android tablets)

My solution was to write a standalone binary called `dk` that uses scripts as the atom of work, cross-compiles to standalone executables, and downloads the runtimes and sysroots it needs on-demand. It sits roughly in the same space as Python and Go.

`dk` is available for Windows, macOS and Linux/glibc host machines with a growing list of cross-compilation targets. Your `dk` scripts are written in an almost complete subset of OCaml 4: all `dk` scripts are OCaml, but not all OCaml code can run in `dk`. The other differences from conventional OCaml are that `dk` comes with a large library included, and that I treat any feature as buggy if the feature does not work on all supported OS-es.

The above origin of `dk` is admittedly odd (and abbreviated), so I was not expecting that `dk` would now be a general-purpose scripting tool. Yet it is. I can wrap, re-use and organize most of my hand-written software as a set of `dk` scripts.

Fair warning: The cross-compilation support in `dk` has had a recent overhaul and not every bug is closed. The error messages suck (you have to scroll up to see the root cause and resolution) but they will improve. Some progress bars are missing. There are also a few experimental features ... `uv`-style imports and an interactive interpreter are the big ones ... which are purposely under-documented because I am worried about `dk`'s API surface.

But it still works well, and you can see some real applications in the Examples section. I'd love if you could give it a kick in the tires and give `dk` some feedback! The issue list is at <https://github.com/diskuv/dk/issues>.

Hello HN!

I've been working on Canine for about a year now. It started when I was sick of paying the overhead of using stuff like Heroku, Render, Fly, etc to host some web apps that I've built. At one point I was paying over $400 a month for hosting these in the cloud. Last year I moved all my stuff to Hetzner.

For a 4GB machine, the cost of various providers:

Heroku = $260 Fly.io = $65 Render = $85 Hetzner = $4

(This problem gets a lot worse when you need > 4GB)

The only downside of using Hetzner is that there isn’t a super straightforward way to do stuff like:

- DNS management / SSL certificate management - Team management - Github integration

But I figured it should be easy to quickly build something like Heroku for my Hetzner instance. Turns out it was a bit harder than expected, but after a year, I’ve made some good progress

The best part of Canine, is that it also makes it trivial to host any helm chart, which is available for basically any open source project, so everything from databases (e.g. Postgres, Redis), to random stuff like torrent tracking servers, VPN’s endpoints, etc.

Open source: https://github.com/czhu12/canine Cloud hosted version is: https://canine.sh

Hello HN,

I built a Typescript library (named socket-call, for lack of a more sexy name) whose goal is to be able to call socket.io events as regular functions.

So you declare your server-side like so:

  ...
  const listenEvents = (services: UserServices) => ({
    // Add your events here, the name of the event is the name of the function
    login: async (username: string) => {
      services._socket.data.user = { username };
      console.log(`User ${username} logged in`);
      setInterval(() => {
        // Calling an event that's handled client-side
        services.showServerMessage(`You're still logged in ${username}!`)
      }, 1000);
      return `You are now logged in ${username}!`;
    },
  });

  ...
  const user = socket.addNamespace<UserEmitEvents, UserListenEvents>(
    '/user'
  );
  
  // Calling an event that's declared server-side
  user.login(username.value).then((message) => {
    console.log('Server acked with', message);
  });
  
  // Handling an event that is sent by the server
  user.showServerMessage = (message) => {
    console.log('Server sent us the message', message);
  }

Hi HN,

I built a CLI for uploading documents and querying them with an LLM agent that uses search tools rather than stuffing everything into the context window. I recorded a demo using the CrossFit 2025 rulebook that shows how this approach compares to traditional RAG and direct context injection[1].

The core insight is that LLMs running in loops with tool access are unreasonably effective at this kind of knowledge retrieval task[2]. Instead of hoping the right chunks make it into your context, the agent can iteratively search, refine queries, and reason about what it finds.

The CLI handles the full workflow:

```bash trieve upload ./document.pdf trieve ask "What are the key findings?"

```

You can customize the RAG behavior, check upload status, and the responses stream back with expandable source references. I really enjoy having this workflow available in the terminal and I'm curious if others find this paradigm as compelling as I do.

Considering adding more commands and customization options if there's interest. The tool is free for up to 1k document chunks.

Source code is on GitHub[3] and available via npm[4].

Would love any feedback on the approach or CLI design!

[1]: https://www.youtube.com/watch?v=SAV-esDsRUk [2]: https://news.ycombinator.com/item?id=43998472 [3]: https://github.com/devflowinc/trieve/blob/main/clients/cli/i... [4]: https://www.npmjs.com/package/trieve-cli

SmartScan is an media management app powered by a CLIP model that automatically organises images by content similarity and enables text-based search across both images and videos. Available on F-Droid (link in GitHub README).

I'm Hemang, co-founder of Clidey. While building Docucod – our platform for generating and maintaining technical documentation – we needed a simple, fast, and flexible way to host the docs.

We started with Next.js + Vercel, but it felt like overkill. SSR wasn’t needed, and we ran into vague webhook errors and deployment issues. It felt like too much complexity for a static documentation site.

So we built Dory – a minimal static site generator optimized for technical documentation. It's built with Preact, Vite, Tailwind, FontAwesome, Mermaid, and Typescript.

What makes Dory work for us: • Reads a folder of .mdx files • A single dory.json defines structure/layout • No SSR, no cloud lock-in • Fast builds, minimal config, deploy anywhere

The goal with Dory is to keep things truly simple — easy to set up, easy to use, and effortless to deploy for anyone building static documentation. Its design is inspired by great tools like Gitbook, Docusaurus, Readme, Mintlify, and Read the Docs. While we plan to add more features over time, simplicity will remain the core principle.

Once it becomes a bit more stable, we'll do a proper comparison to see load times, bundle size, all the good stuff.

It’s early (beta!), but it’s working well for us, and we’d love feedback from the community.

Repo: ⁦https://github.com/clidey/dory

Thanks for checking it out!

I built StellarSnap as a calm, ad-free space to explore NASA’s Astronomy Picture of the Day (APOD) and learn astronomy along the way.

What it includes:

- A clean APOD archive browser with a Random APOD button

- A growing Glossary with term highlighting across the site

- A 2D Orbit Simulator where you can test satellite motion with real physics

- A deeper Encyclopedia, still early, but expanding

- Subtle touches like “see past APODs using this term”

- And more to come

It’s entirely ad-free, cookie-free, and not affiliated with NASA, but I was honored to have StellarSnap mentioned on the official APOD About page by Professor Robert Nemiroff: https://apod.nasa.gov/apod/lib/about_apod.html

Always open to ideas, critiques, or ways to make it better.

Problem:

If you have less than $100k to invest, you get a robo-advisor that asks you 5 questions and dumps you into one of three cookie-cutter portfolios.

If you have more than $100k, you get a human advisor who charges 1-1.5% annually to... basically do the same thing with a smile and calming voice attached.

Meanwhile, institutional investors get custom strategies built around specific durations, target dates, tax situations and actual investment goals. Not because the math is harder—but because the economics only work at scale. Here's the thing: Both traditional advisors and robo-advisors maximize profit by minimizing choice and directing capital into the bias strategies that generate them additional margins. Both just tweak a risk slider and call it "personalization." But institutional-grade portfolio construction doesn't have to be exclusive to the wealthy. The road was paved by platforms like Plaid, brining API connectivity—platforms and asset aggregation into the mainstream. Modern AI completes the picture by making true personalization economically viable via "micro-advise".

No asset transfers, no new custodians, just sophisticated strategies based on your financial goals executed where you already invest coupled with personalized financial planning & budgeting.

Technical Solution:

We've built our MVP wealth management platform that creates truly personalized portfolios by combining institutional capital market expectations stemming 30+ global asset classes. All available through low-fee publicly available ETFs. Our approach:

- SEC licensed & compliant Registered Investment Advisor - Generates unlimited unique portfolio combinations optimized for risk, return & goal specifics.

- Personalizes to individual goals, not generic risk buckets.

- Learns and improves from every user interaction - Provides institutional-grade sophistication without human bottlenecks

- Removes manager bias for in-house strategies - Uses a "glidepath" approach similar to the US retirement target-date structure to maximize achievement certainty of important life goals (down-payment, retirement, etc)

- Seeks to bring elements of habit forming platforms (like Duolingo) into retail wealth. Business Model Innovation:

-Non-custodial + AI architecture enables subscription pricing ($10/month) instead of AUM fees. Users keep control of assets while getting personalized institutional strategies.

Research Validation:

- Glidepath strategies delivered higher values in 76% of scenarios (T. Rowe Price)

- Global diversification outperformed domestic-only in 96% of 3-year periods (Hübner) - Chance of success metrics for significant life goals like retirement & major milestones are measurably improved via behavioral advantages & sequence risk protection (T. Rowe Price).

Early Results:

-Alpha users report 90%+ cost reduction vs. traditional platforms with superior personalization. Institutional style portfolios achieving goal-specific optimization that would cost minimum 10x elsewhere.

-Base model portfolios have outperformed comparable portfolios from existing market incumbent robo-platforms on both an absolute & risk adjusted basis in H1 2025.

What's Different:

This isn't another robo-advisor using basic mean reversion. It's personalization that helps you understands and discover your specific goals and adapts continuously. Think "personal wealth manager in your pocket" rather than "generic portfolio assignment." All that, in a consumer product platform designed to empower retail investors and keep them engaged.

Next Steps:

Currently in invite-only alpha at www.fulfilledwealth.co. We focused early on the portfolio construction & delivery process and are now building out the consumer-facing aspects of the web application.

Looking for feedback from the HN community on our approaches to financial personalization.

One of the biggest context AI LLMs can get from images is their metadata, but it's extremely underutilized. and while PNG and JPEG both offer metadata, it gets stripped way too easily when sharing and is extremely limited for AI based workflows and offer minimal metadata entries for things that are actually useful. Plus, these formats are ancient (1995 and 1992) - it's about time we get an upgrade for our AI era. Meet MEOW (Metadata-Encoded Optimized Webfile) - an Open Source Image file format which is basically PNG on steroids and what I also like to call the purr-fect file format.

Instead of storing metadata alongside the image where it can be lost, MEOW ENCODES it directly inside the image pixels using LSB steganography - hiding data in the least significant bits where your eyes can't tell the difference, this also doesn't increase the image size significantly. So if you use any form of lossless compression, it stays.

What I noticed was, Most "innovative" image file formats died because of lack of adoption, but MEOW is completely CROSS COMPATIBLE WITH PNGs You can quite literally rename a .MEOW file to a .PNG and open it in a normal image viewer.

Here's what gets baked right into every pixel:

- Edge Detection Maps - pre-computed boundaries so AI doesn't waste time figuring out where objects start and end.

- Texture Analysis Data - surface patterns, roughness, material properties already mapped out.

- Complexity Scores - tells AI models how much processing power different regions need.

- Attention Weight Maps - highlights where models should focus their compute (like faces, text, important objects)

- Object Relationship Data - spatial connections between detected elements.

- Future Proofing Space - reserved bits for whatever AI wants to add (or comments for training LORAs or labelling)

Of course, all of these are editable and configurable while surviving compression, sharing, even screenshot-and-repost cycles :p

When you convert ANY image format to .meow, it automatically generates most AI-specific features and data from what it sees in the image, which makes it work way better.

Would love thoughts, suggestions or ideas you all have for it :)

The article provides practical tips on how to effectively read and understand code, including breaking down complex code, identifying key components, and using various tools and techniques to aid the learning process.

Hey HN, recently Apple release their own container manager tooling, but it's missing a "compose-like" tool.

I'm building this CLI as a side-project and a way to help on the usage with the main tool.

It's in a early version, then at the moment I'm trying to be as much as possible compatible with `docker-compose` config file, and in the current version we're supporting two commands: `up` and `down`.

Tikt is a new social media platform focused on short-form video content, offering users the ability to create, share, and discover engaging videos on a range of topics. The platform aims to provide an immersive and entertaining experience for its growing user base.

I needed a Newsreader and my buddy was supposed to build one but this never materialized, at least the final version. I am not a programmer, but I build this on one day with chatGPT. I used DataTau Hackernews clone based on Django as a start. Few lines should be the same now. Added dual language support and added RSS feed fetching support. So it is a mixture between ycombinator and a newsreader.

I know. Not great work. But I was so proud ;-) I know, hackernews clones are a dime a dozen and I used Datatao to start with. Please don't be too harsh with your feedback.

Hey! Check out my "toy" text editor which I use as my daily driver.

Features LSP autocomplete, goto definition, hover info

Tree-sitter support

Color themes (borrowed from the Helix text editor)

Lots of bugs

Macro support

Something like Emacs org-mode: Open test.txt, place the cursor at line 15, and press "Ctrl-C Ctrl-C".

This project was written as a "speed run" — not for speed in terms of time, but rather as an exercise to explore the text editor problem space without overthinking or planning ahead. It’s a quick and "dirty" implementation, so to speak.

https://github.com/firstrow/mcwig

This article discusses a project that combines gRPC and SQLite to create a lightweight and efficient data storage system. It provides a tutorial on setting up and using this combination for building scalable and distributed applications.

I am making a virtual HDMI monitor using Viture Pro XR glasses and an SBC ( currently OrangePi 5 Plus because it has HDMI-in ).

What it does is map the frames from the HDMI input onto a virtual display that is controlled by the IMU data from the glasses ( 3DOF only ). I've put AR in quotes in the title because many won't view those display glasses as true AR but by tracking the head movement it comes close.

I am trying to build kind of a "low cost" version of a virtual screen that acts like a monitor and can be connected to anything that has an HDMI output

I started off using the official Viture SDK to interact with the glasses but have since switched to a reverse engineered implementation of the protocol because their SDK is not available for ARM

Here is a video showing the first version: https://www.youtube.com/watch?v=D6w5kAA22Ts

Big caveat: Performance still needs to improve a lot because the whole frame reading/converting is completely unoptimized for now.

What other solutions do exist out there? * Streaming the computer screen to a headset like Meta Quest/Vision Pro * Connecting a HDMI capture dongle to the Meta Quest directly * XReal Beam ( basically the same as this project but official and for XReal glasses )

And for the obvious question, why I am not use something like a Quest or Vision Pro 1. Comfort 2. Price 3. Comfort

After using those display glasses over HMDs it's hard to convince myself to use a headset for productivity again

I wanted Apple Vision Pros, but I don’t have $3,500 in my back pocket. So I made Apple Vision Pros at home.

This was just a fun little project I made. Currently, the website doesn't work on screens less than 1200x728 (Sorry mobile users!) It also might struggle on lower end devices.

For best results, have a webcam pointing right at you. I tested my website with a MacBook camera.

Any comments, questions, or suggestions are greatly appreciated!

blog: https://blog.andykhau.com/blog/eyesite

check it out: https://eyesite.andykhau.com/

github: https://github.com/akchro/eyesite

$1,500 an hour and still using the software my grandma used to make bingo fliers!?

Hi HN! I'd like to submit for your consideration Tritium (https://tritium.legal). Tritium aims to bring the power of the integrated development environment (IDE) to corporate lawyers.

My name is Drew Miller, and I'm lawyer admitted to the New York bar. I have spent the last 13 years in and out of corporate transactional practice, while building side projects in various languages using vanilla Vim. One day at work, I was asked to implement a legal technology product at my firm. Of course the only product available for editing and running programs in a locked-down environment was VS Code and its friends like Puppeteer from Microsoft.

I was really blown away at all of the capabilities of go-to definition and out-of-the box syntax highlighting as well as the debugger integration. I made the switch to a full IDE for my side projects immediately. And it hit me: why don't we have this exact same tool in corporate law?

Corporate lawyers spent hours upon hours fumbling between various applications and instances of Word and Adobe. There are sub-par differencing products that make `patch` look like the future. They do this while charging you ridiculous rates.

I left my practice a few months later to build Tritium. Tritium aims to be the lawyer's VS Code: an all-in-one drafting cockpit that treats a deal's entire document suite as a single, searchable, AI-enhanced workspace while remaining fast, local, and secure.

Tritium is implemented in pure Rust. It is cross-platform and I'm excited for the prospect of lawyers running Linux as their daily driver. It leverages a modified version of the super fast egui.rs immediate-mode GUI library. The windows build includes a Rust COM implementation which was probably one of the more technical challenges other than laying out and rendering the text.

Download a copy at https://tritium.legal/download or try out a web-only WASM preview here: https://tritium.legal/preview

Let me know your thoughts! Your criticisms are the most important. Thank you for the time.

I picked up programming in late 2023 and been enjoying it now. Wanted to challenge myself and set a stretch goal, so set out to build a bittorrent client.

Most feedback tools are built like people actually want to report bugs. They don’t. Unless you make it dead-simple, or better yet - a little fun.

After shipping a few SaaS products, I noticed a pattern: Bugs? Yes. Bug reports? No.

Not because users didn’t care but because reporting bugs is usually a terrible experience.

Most tools want users to:

* Fill out a long form

* Enter their email

* Describe a bug they barely understand

* Maybe sign in or create an account

* Then maybe submit it

Let’s be real: no one’s doing that. Especially not someone just trying to use your product.

So I built Bugdrop.app - It’s a little draggable bug icon that users can drop right on the issue, type a quick note, and they’re done. No logins. No forms. Just context-rich feedback that your team can actually use — with screenshots, browser info, even console logs if they hit an error.

And weirdly? People actually use it. Even non-technical users click it just because "the little bug looked fun."

I didn’t want to build another "feedback suite". I just wanted something lightweight, fast, and so stupidly simple that people actually report stuff. If you've ever had a user say “something’s broken” and then ghost you forever, you probably get where I’m coming from.

What I’m most proud of? People are actually using it. And their users? They’re actually reporting stuff. Even non-technical ones.

Would love to hear if you’ve faced similar problems, and if this feels like something that would’ve helped in your own projects. Not trying to sell you anything — just sharing something I built to scratch my own itch.

Whereas this is mostly a terminal eye-candy project to get you street cred, it does have some serious aspects.

Firstly it solves the age-old problem of low-contrast text, like when you `ls` a broken symlink and the red background colour is too near your current theme's foreground colour. Tattoy solves this by using none other than the web's WCAG 2.1 contrast algorithm for accessible text.

Secondly, an explicit design goal is that Tattoy should be able to polyfill new terminal protocols, the `xwayland` of the TTY if you will. Say if we want to experiment with completely deprecating ANSI codes, then any application that uses a new protocol can be run in Tattoy which itself runs in any ANSI-standard terminal emulator as normal. You can read more about this idea here: https://tattoy.sh/news/an-end-to-terminal-ansi-codes/

But ultimately this has been something more akin to an art project, something to enjoy for the sheer aesthetic pleasure.

I'm the co-creator and maintainer of https://aframe.io/ and long time Web 3D graphics dev.

Super excited about new techniques to author / render / represent 3D. Spark is a an open source library to easily integrate Gaussian splats in your THREE.js scene I worked with some friends and I hope you find useful.

Looking forward to hearing what features / rendering techniques you would love to see next.

We wanted to build a course for new Mastra devs to get started quickly. However, we knew videos would go out of date and be more difficult to maintain.

We decided to launch our "course" as an MCP server. This way your coding agent actually teaches the course content to you and can help you write the code. We think this is a really interactive way to learn.

Using an editor with MCP support (such as Cursor, Windsurf, or VSCode), your code agent will call the appropriate MCP tools which will return context for the agent. This context tries to instruct the agent that it should be teaching you the content, not just doing the work for you.

The course is still pretty experimental and some models work better than others. Code is available in the Mastra Github repo in the mcp-docs-server package (https://github.com/mastra-ai/mastra/tree/main/packages/mcp-d...)

QRkey is an open-source tool that generates QR codes to securely share encryption keys. It provides a simple and convenient way to exchange sensitive information, such as passwords or cryptographic keys, through the use of QR codes.

This is a personal project I've been working on for a long time now.

I stumbled upon the color quantization problem while doing something related for work. I then found an interesting paper for which I could find no implementations online, and the thing went from "let's implement this paper" to getting pretty obsessed with the whole thing.

It's at an early, eaaaarly stage. There's a lot of work to be done, and it's a memory hog, but generally speaking works quite well, and the output is for the most part very high quality, so I'm happy to share it as beta.

I made this 130 mile capable VTOL drone in only 90 days. It can fly for 3 hours on a single charge. That would make it one of the longest range and endurance 3D printed VTOLs in the world.

This is the thing I'm most proud of building to date!

Before this project, I was a total CAD, 3D printing and aerodynamic modeling beginner. I had only built and flown one VTOL before.

SPECS

Wingspan: 3.9 ft (1200 mm) Length: 2.5 ft (770 mm) Weight: 5.6 lb (2.55kg)

Airframe: foaming PLA (Bambu PLA-Aero) and PETG structural parts printed on A1 printer, CFRP booms and spars

Battery: Li-ion silicon anode Amprius SA08 cells, 6s2p pack by Upgrade Energy Motors: 2807 AOS for lift and cruise (unoptimized) Lifting ESCs: 4 in 1 Holybro Tekko32 F4 45A Cruise ESC: Flycolor Raptor 5 45A Lifting and cruise props: 7042 Gemfan (unoptimized)

Flight controller: Speedybee F405 Wing GPS: M10

Firmware: Ardupilot 4.6.0

---

This video edit ended up shorter than I planned. Being my first Youtube video with significant post production effort, I underestimated the work required to make a longer in-depth video with voiceover, edited footage, etc.

When I dug into systems theory, the thing I found missing early on was a good editor for diagrams while exploring or explaining systems. So I used Graphviz, and found myself typing boilerplate and constructions that I found cumbersome.

The editor I envisioned would be close to natural language, with a minimal syntax and a clear, but flexible semantics.

So I started building a DSL and an editor for myself, but soon found there was a lot to learn, and a lot of pitfalls to avoid. It grew, and I had to revisit my goals with this project.

That was the moment I thought: let me give back to the community.

I created a spec for the language I had in mind, Minimal Systemigram Description Language. And a browser based and wails based desktop editor. And a Github page. If you want to jump there right away: https://stefankober.github.io/minimal-systemigram-descriptio.... There is extensive help in the editors.

To check it and learn, I recreated diagrams from introductory books I read. This in turn made me update the spec and the editor again.

Today I released it on Github in version 0.1.0 for you to assess.

It has a Github pages version of the editor for immediate trial, the spec, the desktop editors and the library, all open source.

Builds are there for Ubuntu, Mac and Windows, the latter via Github Runners, and I tested all of them on the systems I have (one of each :D).

I am far from a good programmer, but I put a lot of love into it. I hope it shows in the details.

If you are a systems practicioner, learner, teacher, or just interested, it might be something for you.

Let me know what you think, good or bad. Happy to answer questions.

s3mini is an open-source, lightweight AWS S3 client for the command line. It provides a simple and efficient way to interact with Amazon S3 storage, allowing users to perform common file management tasks such as uploading, downloading, and deleting files.

Hey all. I built an interactive spreadsheet, making it easy to run AI automations. Instead of combining multiple tools like Google Sheets, Zapier, Make, etc, it replaces all of them in a single table.

Currently solving for sales and marketing automations to start with, which makes a direct, affordable alternative to Clay. Would love to get feedback from the community.