Hacker News

Finding a good data structure for a word processor is a difficult problem. My notebook diaries on the problem go back 25 years when I was frustrated with using Word for my diploma thesis - it was slow and unstable at that time. I ended up getting pretty hooked on the problem.

Right now I’m taking a professional break and decided to finally use the time to push these ideas further, and build MiniWord — a WYSIWYG word processor in Python.

My goal is to have a native, non-HTML-based editor that stays simple, fast, and is hackable. So far I am focusing on getting the fundamentals right. What is working yet is:

- Real WYSIWYG editing (no HTML layer, no embedded browser) with styles, images and tables.

- Clean, simple file format (human-readable, diff-friendly, git-friendly, AI-friendly)

- Markdown support

- Support for Python-plugins

Things that I found:

- B-tree structures are perfect for holding rich text data

- A simple text-based file format is incredibly useful — you can diff documents, version them, and even process them with AI tools quite naturally

What I’d love feedback on:

- Where do you see real use cases for something like this?

- What would be missing for you to take it seriously as a tool or platform?

- What kinds of plugins or extensions would actually be worth building?

Happy about any thoughts — positive or critical. Greetings

This is a CAD by code project I have been working on on my free time for more than year now.

I built it with 3 goals in mind:

- It should be familiar to CAD designers who have used other programs. Same workflow, same terminology.

- Reduce the mental effort required to create models as much as possible. This is achieved by:

    - Provide live rendering and visual guidance as you type.
    - Allow the user to reference existing edges/faces on the scene instead of having to calculate everything.
    - Provide interactive mouse helpers for features that are hard to write by code: Only 3 interactive modes for now: Edge trimming, Sketch region extrude, Bezier curve drawing.
    - Implicit coding whenever possible: e.g: There are sensible defaults for most parameters. The program will automatically fuse intersecting objects together so you do not have to worry about what object needs to be fused with what.

- It should be reasonably fast: The scene objects are cached and only the updated objects are re-computed.

I think I have achieved these goals to a good extent. The program is still in early stages and there are many features I want to add, rewrite but I think it is already usable for simple models.

Update to add more details: This is based on Opencascade.js WASM binding. So you get all the good things that come with any brep kernel. Fillets, chamfers, step import and export...

The scene is webview but the editing is in your local file. You use your own editor and the environment you are familiar with.

One important feature that I think make this stand out among other code based cad software is the ability to transform features not just shapes. More here: https://fluidcad.io/docs/guides/patterns You can see it in action in the lantern example: https://fluidcad.io/docs/tutorials/lantern

You give it a task and it works in the background until it's done.

I built this because I wanted OpenClaw without the self-hosting, pointed at actual day-to-day work. I’m thinking less personal assistant and more helpful colleague.

Here’s a short demo video: https://www.loom.com/share/00d11bdbe804478e8817710f5f53ac61

The main interface is a web app where you can watch work happen in real time (agents spawning, files being written, use of the CLI). There's also an iMessage integration so you can fire a task asynchronously, put your phone down, and get a reply when it's finished.

Under the hood, there's an orchestrator (Claude Opus 4.6) that routes to the right domain-specific model for each subtask: browsing, coding, research, and media generation.

For complex tasks it spins up parallel sub-agents that coordinate through the shared filesystem. They have persistent memory across sessions so context compounds over time.

I’ve packaged it with a bunch of pre-installed skills so it can execute in a variety of job roles (sales, marketing, finance) at runtime.

Here are a few things Eve has helped me with in the last couple days:

- Edit this demo video with a voice over of Garry: https://www.youtube.com/watch?v=S4oD7H3cAQ0

- Do my tax returns

- To build HN as if it was the year 2030: https://api.eve.new/api/sites/hackernews-2030/#/

AMA on the architecture and lmk your thoughts :)

P.S. I've given every new user $100 worth of credits to try it.

https://twill.ai/). Twill runs coding CLIs like Claude Code and Codex in isolated cloud sandboxes. You hand it work through Slack, GitHub, Linear, our web app or CLI, and it comes back with a PR, a review, a diagnosis, or a follow-up question. It loops you in when it needs your input, so you stay in control.

Demo: https://www.youtube.com/watch?v=oyfTMXVECbs

Before Twill, building with Claude Code locally, we kept hitting three walls

1. Parallelization: two tasks that both touch your Docker config or the same infra files are painful to run locally at once, and manual port rebinding and separate build contexts don't scale past a couple of tasks.

2. Persistence: close your laptop and the agent stops. We wanted to kick off a batch of tasks before bed and wake up to PRs.

3. Trust: giving an autonomous agent full access to your local filesystem and processes is a leap, and a sandbox per task felt safer to run unattended.

All three pointed to the same answer: move the agents to the cloud, give each task its own isolated environment.

So we built what we wanted. The first version was pure delegation: describe a task, get back a PR. Then multiplayer, so the whole team can talk to the same agent, each in their own thread. Then memory, so "use the existing logger in lib/log.ts, never console.log" becomes a standing instruction on every future task. Then automation: crons for recurring work, event triggers for things like broken CI.

This space is crowded. AI labs ship their own coding products (Claude Code, Codex), local IDEs wrap models in your editor, and a wave of startups build custom cloud agents on bespoke harnesses. We take the following path: reuse the lab-native CLIs in cloud sandboxes. Labs will keep pouring RL into their own harnesses, so they only get better over time. That way, no vendor lock-in, and you can pick a different CLI per task or combine them.

When you give Twill a task, it spins up a dedicated sandbox, clones your repo, installs dependencies, and invokes the CLI you chose. Each task gets its own filesystem, ports, and process isolation. Secrets are injected at runtime through environment variables. After a task finishes, Twill snapshots the sandbox filesystem so the next run on the same repo starts warm with dependencies already installed. We chose this architecture because every time the labs ship an improvement to their coding harness, Twill picks up the improvement automatically.

We’re also open-sourcing agentbox-sdk, https://github.com/TwillAI/agentbox-sdk, an SDK for running and interacting with agent CLIs across sandbox providers.

Here’s an example: a three-person team assigned Twill to a Linear backlog ticket about adding a CSV import feature to their Rails app. Twill cloned the repo, set up the dev environment, implemented the feature, ran the test suite, took screenshots and attached them to the PR. The PR needed one round of revision, which they requested through Github. For more complex tasks, Twill asks clarifying questions before writing code and records a browser session video (using Vercel's Webreel) as proof of work.

Free tier: 10 credits per month (1 credit = $1 of AI compute at cost, no markup), no credit card. Paid plans start at $50/month for 50 credits, with BYOK support on higher tiers. Free pro tier for open-source projects.

We’d love to hear how cloud coding agents fit into your workflow today, and if you try Twill, what worked, what broke, and what’s still missing.

Microsoft terminated the account VeraCrypt used to sign Windows drivers - https://news.ycombinator.com/item?id=47686549

https://xcancel.com/vxunderground/status/2042483067655262461

https://old.reddit.com/r/pcmasterrace/comments/1sh4e5l/warni...

https://www.bleepingcomputer.com/news/security/supply-chain-...