Once upon a time selling software worldwide was easy. You would have a PayPal account, sell your stuff without VAT applied, and at the end of the year you told the tax office how much you had sold in total. Now it is almost undoable, at least from Europe.

Why not go to the App Store?

“But hey, there are the App Stores, they take all the work off your hands.” That is partly true, at least for billing and taxes, but it comes with other drawbacks: a review for every single app version; a lot is forbidden in the App Store, technically and in terms of content; you know nothing about your customers; the fees are between 15 % and 30 %; you do get paid out in Euro, but at Apple’s own rate on the day of payout rather than the day of sale; and Apple can throw you out at any time — then go and try to take on a trillion-dollar corporation.

What is so complicated about it?

Selling things in your own country, in my case Germany, is comparatively manageable: you write an invoice with your country’s VAT and that is that.

But as soon as you sell to other EU countries, you have to apply (and know) the standard tax rate of the destination country for software sales. If your customer is a company, you can ask for their VAT identification number (VAT ID) and issue a “reverse charge” invoice, so without tax, and they take care of it. But if the VAT ID turns out to be wrong, you owe that amount to your tax office after all. Worldwide, every country then has its own rules again, and in some of them you have to remit the VAT directly in the destination country — that depends on minimum turnovers which can range from 0 to well into the hundreds of thousands.

In Europe there are fortunately exemptions — below 10,000 Euro of annual turnover in other EU countries you may simply charge your home tax rate — and otherwise the One-Stop-Shop (OSS) procedure. That at least saves you from reporting the taxes separately in every EU country, but you still have to know which taxes to charge. And that is not even uniform within a single country: Heligoland belongs to Germany, but for VAT purposes it counts as third territory (§ 1 (2) of the German VAT Act) — no German VAT applies there. The same goes for Büsingen am Hochrhein, the German enclave in the middle of Switzerland. Other EU countries have their own special zones. That is why the postal code is asked for everywhere. File it under useless knowledge ;)

How do I get my money?

Now we know how the invoice data has to look and how the taxes work. But we still have to get at the money as well. No problem, we will just use PayPal. But not everyone wants to or can use PayPal, and when PayPal gets into a really bad mood because a customer complained, they simply might close your account.

So let us take a payment provider — and there are fewer of them than you might think. The vast majority use Stripe, they are in on pretty much everything. To be fair: for a European merchant this runs through Stripe’s Irish entity and pays out in Euro. But as soon as a customer pays in a different currency it gets converted, and that costs around 2 %. And that is where the actual problem sits: we live here with the Euro, yet we fall back on providers whose internal reference currency is the dollar. Every station that converts takes a cut — and you are never the one setting the rate.

So we could pick a European payment provider like Mollie. But they really do nothing other than accept the money and charge fees for it. And when a customer reverses a payment without giving you the chance to make a refund, some payment methods will cost you more than 10 EUR right away — you end up paying on top.

But surely there is an easier way? Merchant of Record

You can save yourself a lot of that by using a so-called merchant of record (MoR). They then sell your software in their own name and on their own account. They take care of all tax matters and once a month you get the money transferred, minus the taxes and their fees.

I have been using Paddle from London for years and it really works quite well. You can even run everything in Euro, which avoids some losses. Their support is not particularly fast, but it works. You know all your customers and their data. But a MoR has rules too and does not sell everything. And you also have to trust that it will keep working.

Recently, though, the website for one of my products had to go through a second review for content reasons. That got sorted out and Paddle resolved it promptly — still, I took it as a reason to have a look around the MoR market. Just as a plan B for the worst case. And there are not nearly as many that really fit…

There are more MoRs than the ones I name here — what I was after is the pattern that runs through almost all of them: they are not based in the EU. Lemon Squeezy belongs to Stripe by now and is visibly drifting towards Stripe Managed Payments — I would not start there any more. FastSpring has been around since the early days and still looks like it. Both USA. And even the fresh Swiss startup tiun uses Stripe, so you end up half in the USA again.

A MoR from the EU would be good then. They do exist, just in two flavours: young and unfinished, or old and cut for corporations. Creem from Estonia only offers a small range of payment methods, not even PayPal, which roughly half of my buyers use. cleverbridge from Cologne and Nexway from France, on the other hand, have been doing this for over twenty years — but with an annual fee, pricing on request and a sales call instead of a signup form. That is nothing for a single developer. That leaves the hope of Vatly from the Netherlands with its Europe-first approach — so far only a waiting list, though.

In any case, what is left for small indie software vendors is pretty thin. You keep running into the same companies here: the alternative distribution channel Setapp, for instance, is intertwined with Paddle, and Stripe is everywhere too and even wanted to buy PayPal — over 50 billion dollars together with the investor Advent, PayPal’s board found it too little, and by the end of August 2026 the plans were off the table again.

Wishes

I have not even talked about legal aspects, e-invoicing and different currencies. It would be desirable if all of this were much simpler and more carefree. If the EU, in the interest of its citizens, would create the foundations for sole traders to sell software worldwide very easily, without having to dig deeply into it or depend on resellers, because doing it yourself is barely realistic. Then the world could move a little closer together again.

P.S.

Of course the topic got to me and I went and programmed my own little shop, with a checkout dialog and everything I had learned. Whether I will actually use it, I do not know yet…

An update with improvements to everyday workflows. Here’s a quick overview of the key changes.

Smarter Category Settings

For recognized contacts, you can now define how a category is made: from the most frequently used category, from the category of the most recent receipt, or not at all. In addition, each contact can be assigned a fixed default category that always takes precedence.

Re-run Recognition

Two new commands re-apply recognition to the selected receipts: either the searchable text layer is rebuilt, or amounts, date and vendor are re-read – just like a fresh import.

Automatic Recovery for Damaged Libraries

If a library’s info file is missing or damaged, it is restored from its backup. Otherwise, the app offers a repaired copy that opens normally again – optionally including orphaned files, which are brought back in as new documents.

“Save As” via the Option Key

Holding the Option key turns “Open PDF Document” and “Open Original” in the document list into “Save As.” This lets you quickly store a copy in another location.

Screenshot in the Feedback Form

The feedback form has a new “Screenshot” button that captures part of your screen and attaches it to your message with a single click.

All details are available at receipts-app.com.

Tesseract 5 OCR, optimized for Apple Silicon. We’ve upgraded to the latest Tesseract engine and tuned it specifically for M-series Macs. The result is faster recognition und better accuracy.

Apple Vision OCR with automatic language detection. No more picking a language before you scan. PDFify figures out what it’s looking at and gets to work — whether it’s a German contract, a Chinese manual, or an English research paper.

Compression, redesigned around four clear modes. Get full control over the trade-off between quality and size: compress only embedded images and keep real text sharp and searchable — or rasterize entire pages in color, grayscale, or black & white for maximum size reduction. One decision, predictable result.

Full French localization. Every menu, every label, every dialog — bonjour 🇫🇷

Update PDFify today and give it a spin …

Three weeks ago, I published a sandbox to keep the AI somewhat in check. The built-in safeguards that Claude Code offers, for example, seemed untrustworthy to me, since they could usually be overridden by my instructions to the app. On top of that, I had a very uneasy feeling because sensitive information like SSH keys or project-specific confidential data in .env.local wasn’t inherently protected from the tools’ access.

When I looked around at the available options, most of them seemed quite complex or restricted my workflow — for example, working inside a Docker environment. I had something in mind that would be as simple as using .gitignore. So I got straight to work — ironically with the AI — building a cage for it.

We decided to use Apple’s macOS sandbox functionality. In principle, the restrictions I had specified in .bxignore simply needed to be translated into sandbox instructions. One feature that was important to me was the ability to also protect my development environment, since sensitive operations usually happen within the IDE — in my case, Visual Studio Code.

It quickly became clear that the ignore file alone wasn’t enough. I added a configuration that could accommodate the specifics of each application being used. This also allowed me to grant access to multiple directories, so I could work on several projects simultaneously. For this reason, I introduced a ~/.bxconfig.toml.

I can now type bx projects to launch my development environment. Visual Studio Code opens with access to my projects. Within those projects, all sensitive data is protected by .bxignore. On top of that, a global baseline configuration protects areas like .ssh and other sensitive locations. Neither the IDE nor the tools invoked within it — such as Claude Code — can access this data.

After a while, I decided to use Visual Studio Code exclusively for AI work and installed the more open VSCodium alongside it for everything I didn’t want to do with AI, because it’s really hard to fully “clean up” VSCode.

Of course, none of this provides 100% security, but it doesn’t have to. It offers enough protection to not feel completely exposed, and it barely restricts the usual workflows. For me personally, it’s a great fit, and I’d be happy if others found it useful too.

Give it a try:

brew install holtwick/tap/bx 

If you work with AI-powered coding tools today — be it Claude Code, Copilot, or Cursor — you quickly get used to the productivity boost. What’s easy to overlook: these tools have full access to your entire file system. Every command the AI executes runs with the same permissions as you.

That might be fine for a hobby project. But if you’re handling client data, have license keys on disk, SSH keys for production servers, or simply private photos in your home directory — at some point, you start feeling uneasy.

The Existing Options

Of course, there are ways to protect yourself:

Docker containers offer good isolation, but they’re cumbersome for typical macOS development workflows. You need to mount volumes, configure IDE integration, and the workflow never feels quite native.

Claude’s built-in restrictions — the tool politely asks before modifying files. But “asking” isn’t protection. A hallucinated file path, a misinterpreted command, and suddenly the AI reads something it shouldn’t have seen. The trust is based on the model’s behavior, not on a technical barrier.

VSCode Workspace Trust protects against automatic code execution, but not against file system access from a terminal or an extension.

None of these solutions really convinced me.

The Idea: Use the macOS Sandbox

macOS ships with sandbox-exec, a kernel-level sandbox that Apple itself uses for App Store apps. The idea: a tool that launches any application so it can only see the current project directory — and nothing else.

The result is bx. A CLI tool you put in front of your actual command:

bx claude ~/work/my-project

That’s it. Claude Code starts with full access to ~/work/my-project — but ~/Documents, ~/Desktop, ~/.ssh, other projects, and everything else in the home directory is invisible.

Built in Two Days — with Claude Code Itself

The ironic part: bx was built entirely with the tool it’s designed to protect against. In two intensive days, Claude Code wrote the bulk of the code — from sandbox profile generation to CLI argument parsing to app discovery via macOS Spotlight.

It worked surprisingly well. Claude knew the (undocumented!) Apple Sandbox Profile Language and correctly handled its quirks — for instance, the fact that deny rules in SBPL always take precedence over allow rules, regardless of order. This means you can’t simply lock down the entire home directory and then add exceptions. bx solves this by scanning the home directory and selectively blocking only sibling directories.

More Than Just Claude Code

bx isn’t limited to one tool. It supports VSCode, Xcode, Terminal, and arbitrary commands out of the box. Any app can be added via a TOML configuration file:

[apps.cursor]
bundle = "com.todesktop.230313mzl4w4u92"
binary = "Contents/MacOS/Cursor"

The tool finds apps automatically via their macOS bundle ID — no hardcoded paths needed. And if you regularly work with the same projects, you can configure default directories per app:

[apps.code]
workdirs = ["~/work/project-a", "~/work/shared-lib"]

A simple bx code then opens VSCode with exactly those directories — sandboxed.

Fine-Grained Control

What makes bx especially practical: you can hide files even within an allowed project directory. A .bxignore file in the project works like .gitignore:

.env
.env.*
*.pem
secrets/

This keeps environment variables and certificates invisible, even when the project directory itself is fully accessible.

With bx --dry you can preview exactly what will be protected — without launching anything. It gives you a clear picture of the actual isolation.

The Growing Attack Surface

What many people underestimate: modern AI coding tools are far more than chat interfaces. Claude Code, for example, can execute shell commands, create and delete files, and access external services via MCP servers (Model Context Protocol) — databases, APIs, cloud infrastructure. On top of that, there are skills and hooks that can trigger actions automatically.

All of this happens in the user’s context, with their full permissions. bx’s sandbox operates at the kernel level: whether it’s an rm command, an MCP tool, or an automated hook trying to access ~/Documents — the operating system blocks the access before it even happens. This is fundamentally different from a software-level restriction that could be bypassed.

Important to note: within the allowed project directory, everything is permitted — that’s intentional, otherwise you couldn’t work. If you have sensitive files there, you can selectively exclude them via .bxignore.

Being Honest

bx is not a high-security vault. sandbox-exec is an undocumented Apple API that could change with any macOS update. There’s no network protection — API calls, git push, and npm install all work normally. And sandbox rules are generated once at launch; directories created afterwards are not automatically protected.

But as a pragmatic security layer for everyday development, it works remarkably well. It’s the difference between “the AI can theoretically read everything” and “the AI can only see this one project.”

That said, to be clear: bx was built with the best of intentions and to the best of my knowledge, but it comes with no guarantees. It’s not a replacement for a professional security solution, and it doesn’t absolve anyone from thinking for themselves. If you’re working with truly critical data, don’t rely blindly on any single tool — no matter how well it works. bx is an additional layer of protection, not a substitute for common sense.

Try It Out

bx can be installed via Homebrew or npm:

brew install holtwick/tap/bx
# or
npm install -g bx-mac

The code is open source: Codeberg holtwick/bx-mac GitHub holtwick/bx-mac

I’d love to hear your feedback, feature requests, and of course stars. And if you have interesting use cases — let me know!

This blog post was written by Claude (Anthropic’s AI) and reviewed and approved by me. Fitting, given the topic, I’d say.

Initial situation

As a software developer, I face a fundamental dilemma: developing high-quality open-source software—such as my end-to-end encrypted video conferencing solution Briefing—requires a considerable investment of time and capital. Without sustainable funding, my only option is commercial exploitation, even though I would prefer to make the software completely free and continue to develop it intensively. This problem affects numerous developers in Europe.

Core idea

The EU should establish a permanent funding system that promotes open source development through performance-based remuneration. Specifically, I propose an EU-operated platform (comparable to GitHub or Codeberg.org) that distributes funding based on measurable success criteria.

How it works

The platform would evaluate the usefulness and quality of projects using objective metrics:

• Community engagement (ratings, stars)
• Technical reach (integration into other projects, downloads)
• Maintenance quality (responding to issues, fixing bugs)
• Documentation and support

Funding would be distributed proportionally, with upper limits per project/person to prevent abuse.

Benefits for all involved

• For developers: Direct link between performance and remuneration; opportunity to focus entirely on open source development
• For the EU: Building digital sovereignty; control over quality standards (e.g., EUPL licensing, developer verification); promotion of European innovation; reduction of dependence on non-European platforms
• For society: Access to secure, transparent software; strengthening of the European tech ecosystem

Conclusion

This initiative would create systematic incentives for the development of high-quality open source software while promoting European values such as transparency, data protection, and digital sovereignty.

Receipts Space 3.0 is here – a major update with lots of new features. Here’s a quick overview.

Audit Compliance (GoBD)

For anyone who needs to store receipts in compliance with regulations, there’s now a dedicated mode. Confirmed entries become read-only, and all changes are logged. A history timeline shows at a glance who changed what and when.

End-to-End Encryption

If you store your library in the cloud or on a USB stick, you can now encrypt it with a password. Synchronization between multiple Macs still works – as long as all devices know the key.

New Dashboard

The dashboard has been completely redesigned. In addition to income and expenses, it now shows open amounts and trends compared to the previous year. A click on contacts, categories or tags filters the view.

Folder Instead of Package

The file format has been extended with a new option: The library can now also be saved as a regular folder. This solves synchronization issues with iCloud and other services.

Of course, there are many more changes. All details are available at receipts-app.com.

What crazy times we live in, and now everything is becoming even more absurd with President Trump. Regardless of the big-picture political situation, the goal should now be to become independent of the US and strengthen the EU. There is also a lot that can be done in the private sphere, and I would like to gradually present alternatives for US services and products in a small series.

Early 2020, I had tried to sketch out in my article “An IT Strategy for Europe” what I thought such a step towards digital sovereignty might look like in broad strokes. Not much is happening in this regard.

I would like to offer the following criteria for achieving independence and reliability:

• Self-hosting → If you operate your services yourself, no one can shut them down and the data belongs to you.
• Decentralized → A distributed system is less susceptible to outages and censorship.
• Open source → The software cannot disappear and can be verified.

Image by mistral.ai

Selfhosting

It is so nice and convenient to use the services of large providers like Google, Microsoft or Apple, but more often than not you pay with your personal data. Even services like Apple can quickly change their privacy-friendly stance; there are already signs of this and the history of comparable services makes trust shrink.

Home network

Unfortunately, operating your own server is not for everyone, but it is less complicated than you might think. You can start at home with a NAS. I own a Synology (Taiwan). It comes with many services of good quality that cover the essentials. But actually it can be any computer, the main thing is that Docker can be operated on it.

Docker is the key to really easy and secure operation of “self-hosted services”. There is an almost infinite number of solutions for every problem.

For example, I run Home Assistant (open source) on my Synology, which is the dashboard for all devices and sensors in my own home that are somehow connected to the network. For photos, I use Immich (open source), which also has features that can keep up. A VPN connection - in my case WireGuard via a fritz.box - allows me to use all services while on the road.

Internet

But even running a Docker service on the internet is not rocket science. At Hetzner (promo link), for example, you can set up a virtual server for less than 5 EUR and get it ready to go with Docker. After a few preparations (https://github.com/holtwick/selfhosted?tab=readme-ov-file#selfhosted) to connect your own domain to the IP, you’re ready to go.

I run many services there, but for private use I mainly use nextCloud. The look is a bit outdated in some places, but it serves its purpose for file sharing and other things you know from iCloud, for example.

Decentralized

Everyone uses the internet’s most famous decentralized service: email. Actually, the whole magic of the internet is its decentralized structure. If something fails somewhere, the information finds another way, just like an ant trail.

Large providers are usually centralized. Of course, they try to distribute the load in the background, but these services are still technically vulnerable to disruptions, data loss and security breaches.

All the better that there are now more “federated” services again. Lately, Mastodon has become particularly well known as a Twitter /X alternative. But in this so-called Fediverse, other solutions are also emerging that can then also connect with each other. A good example of this is the YouTube replacement PeerTube.

But there are other forms of decentralized data processing. One movement that I particularly like is called Local First, which again emphasizes the importance of data being available locally. Storing the same data in different physical locations is also a form of decentralized structure. The prime example of this is versioning systems like git.

Open Source

Free and open software is the cornerstone of deeper trust. First, open software is not so quickly “out of the world”; it exists a thousand times over in copies. Secondly, with a little expertise, you can see exactly what the software does. And thirdly, it can be adapted, which in turn contributes to the project. It’s a digital form of volunteer work, without having to join an association ;)

Further links

• Kuketz blog on the same topic with interesting links and tips (German):
  https://www.kuketz-blog.de/unplugtrump-mach-dich-digital-unabhaengig-von-trump-und-big-tech/
• Directory of European alternatives:
  https://european-alternatives.eu
• General search for alternatives:
  https://alternativeto.net
• Lots of pre-installed self-hosted projects, good for testing:
  https://adminforge.de

After the successful launch of XML2Invoice, many new features and improvements have been added, so the renaming to E-Invoice Space is now taking place.

New layout

The space is now used more sensibly, with only two areas: the PDF preview and the input area. It is also possible to adjust the size ratio between the two areas. There is now a general division between reading and writing to better highlight the strengths of E-Invoice Space and simplify access to the functions.

Create your own invoices

In the Write area, in addition to enriching an existing simple PDF with e-invoice data, a completely new invoice can now be created. All the necessary data can be conveniently entered and a preview is generated immediately. In the PRO version, it is also possible to select an individual background design (stationery) and upload your own fonts in TTF format.

EN 16931 compatibility

E-Invoice Space now also meets the requirements of the EN 16931 standard, not just BASIC and MINIMAL as before.

Overall, the application has become more comprehensive and user-friendly, enabling quick results. As usual, everything takes place locally, so that the web application behaves like a locally installed application. No data is stored or transferred to a cloud service.

…with our new Swiss army knife for e-invoices. Following the latest update, e-invoices can now be easily created online. Even with your own stationery and fonts. The result is a PDF that is compatible with all required standards, including EN 16931, XRechnung, ZUGFeRD and PDF/A.

The highlight: invoices that were previously created using Word or similar programs can be converted into an e-invoice in no time at all. Simply upload the PDF of the existing invoice, the values are read out as if by magic and the result is a standard-compliant e-invoice in ZUGFeRD format. This means that the electronic data has been embedded in the PDF as XML and the other technical requirements have also been met.

The result can be quickly saved and sent. But also in our Mac tool Receipts.

But that’s not all. Received e-invoices, whether XML or PDF, can simply be dragged into the XML2Invoice window and everything is readable and ready for payment or further processing.

As I said, the Swiss army knife of e-invoicing 😎

Write your first e-invoice now!

Update 2025-01-29: XML2Invoice is now called E-Invoice Space

Worried about e-invoices? With XML2invoice you can start the new year relaxed…

XML2Invoice is a web-based app that converts your “normal” PDF invoice into XML format: Either into a pure XML file or into a ZUGFeRD PDF file that looks exactly like your invoice and in which the prescribed XML data is embedded.

And it also works the other way around: XML2Invoice generates an electronically readable invoice in ZUGFeRD format from XML files that can no longer be read by humans, which looks like a standard PDF invoice on the outside, but also contains the XML data. Readable for humans and machines. If desired, you can import the PDF with the embedded XML data into Receipts with a click of the mouse.

Start now for free on xml2invoice.com !

Update 2025-01-29: XML2Invoice is now called E-Invoice Space

PDFify can now be updated to the latest version 4.0. Many PDFify users are looking forward to this major version update with improvements and new functions.

PDF/A Support

Many PDFify users keep electronic documents that they need to archive for the long term.

PDF/A - Portable Document Format Archivable - enables standardized long-term archiving of documents. As of macOS 11, PDFify now offers to save the document as PDF/A-2u by default in the settings.

The “classic” PDF, which supports the embedding of links, graphics, audio and video files as well as optional encryption, is of course retained in PDFify.

Finder Extensions / Quick Actions

To quickly convert several existing PDFs “in batch” to PDF/A, the quick actions in the Finder Extension can be supplemented with “Convert to PDF/A”.

There is also a new Finder extension for converting documents into a PDF with PDF/A format. However, the existing extensions also generate PDF/A if the option has been set in the settings.

Faster display of PDFs on the web

Furthermore, you can now also select the linearized PDF, which is optimized for fast display on the Internet. The first page is then already displayed during the download, while the following pages are still being loaded.

Standardized maximum page size

PDFify now allows you to limit the maximum page size so that you do not end up with unsightly huge pages. By default, the page size is set to DIN A4 with the update. In the settings, you can adjust the value to the original size or US letter.

Sequence during import

Sometimes the individual pages of a document are available as separate image files. In the new version of PDFify, these are now reliably imported in the sort order familiar from the Apple Finder. This allows individual scans of pages to be quickly merged into one PDF document.

Try now for free

When I started programming in the 80s, the situation was simple: data was written to a file on a local disk. If files needed to be exchanged, a floppy disk was simply inserted into another computer and edited.

Later, floppy disks and CD drives disappeared and files were either exchanged by e-mail or the data was stored directly on a server. Even Microsoft Word moved to the cloud at some point.

However, moving data from the local computer to the cloud created new problems. What if the provider closed its service? However, it was not only data loss, but also being trapped by the provider because the data could no longer be retrieved from the service that increasingly became a problem for some and a business model for others.

Local-First

The local-first movement wants to bring the data back to the user while retaining the advantages of the internet. A robust and widely accepted solution has been found for the simultaneous processing of data with CRDT, but not yet for the exchange of data. This is because it is not (yet) possible to do completely without services on a server. Even with peer-to-peer, where the devices mainly communicate directly with each other, the connection must be mediated by servers at the beginning.

In an ideal local-first world, the following criteria should be met with regard to the exchange of data:

1. data is processed and stored locally (offline).
2. the sync can be interrupted for a longer period of time, but data can be processed locally during this time and still be identical everywhere after a new sync (CRDT).
3. data should not be visible on the move (E2EE).

And I would also like to add:

4. the whole thing should also work with the technology of the 80s.

Why? For reasons of resilience, because there are many reasons why things could go offline.

Resilient Sync

For this reason, I propose a data exchange format that works both in the file system and on the Internet. It should be so simple that the implementation can work on any underlying data carrier or service.

Log of changes

To start with, each client writes a kind of simple, continuous log with the changes. We call the position of the changes index and it starts at 0 and continues in whole numbers: 0, 1, 2, 3, .... Usually these changes are CRDT compliant, but this is not significant for the protocol. This data can also be stored in encrypted form. Let’s call this data.

Each client is given a unique identifier, usually a unique ID (UUID), we call it clientId. The change logs are stored linked to the clientId. We will call a collection of such logs workspace.

We can enrich further data, such as a timestamp, which can be useful if we want to process the data changes historically or implement a kind of endless “undo”.

It is also conceivable that each new entry contains a hash of the previous entry in order to ensure data consistency in the style of a blockchain. Further refinements in the direction of the Merkle tree are also conceivable. However, a hash on the content of the current entry can also contribute to data security.

Assets, blobs, the big binary chunks

The reality is that there is also larger data that rarely changes: Images, videos, audios, i.e. files. These are not part of the content changes and would quickly bring data synchronization to a standstill. In addition, they are not always needed immediately and could also be loaded “on demand”. I therefore suggest treating these files separately from the changes. Let’s call them asset.

But here, too, the data should be stored according to clientId and in ascending order with index. The data sets can thus refer to an asset, e.g. with a data entry in the form of a URL that contains all the necessary information:
asset:///<clientId>/<index>/<filename>?size=<sizeInBytes>&type=<mimeType>&hash=<checksumOfContents>. An example could look like this asset:///abc/1/test.txt?size=100&type=text%2Fplain&hash=1a2b3c.

Benefits

The key advantage of this method is that we always know where the next data will appear. Because if a client has just written the index ‘123’, the next one will be ‘124’.

Why is this important? For the following reasons:

1. we are not dependent on being notified of new data (“push”), but can also ask for it ourselves (“pull”).
2. we can load the individual entries even without knowing anything about their content. A sync can even take place without an intermediary having to “understand” the data.
3. we notice immediately if data is missing and can request it again.
4. the data can be replicated as often as required, there does not have to be just one sync source. It therefore makes sense to use it as a backup.
5. clients that do not have a direct connection to each other can use “stupid copying processes”.
6. data exchange can be easily and comprehensibly documented, which can be important when recognizing legally compliant stored data for tax and compliance purposes.
7. there are no conflicts when storing the data because it is only updated but never deleted (“append only”).

Databases

Let’s start with the implementation as a database. As described, a table with the following fields would be sufficient:

• index: Integer
• clientId: String or integer
• data: String or binary
• timestamp: Integer (optional)
• prevHash: String or integer (optional)

This would look similar for the assets.

Database can refer to both the local storage of the client, e.g. in the IndexedDB, and the storage on a synchronization server.

Filesystems

The data is stored in a directory in a file system. Metadata, such as the clientId of the creator and details such as the encryption used, are stored in a JSON file called index.json.
Furthermore, there is a directory for each client that is named after the clientId.

These in turn each contain two directories:

1. changes
2. assets

The changes are recorded in changes and numbered consecutively. The same is done in assets with the binary data described.

Modern file systems have no significant restrictions on the number of files per directory, but it can’t hurt to limit the number anyway. The following algorithm in TypeScript ensures an even distribution:

/**
 * Distribute file, named by natural numbers, in a way that each folder only
 * contains `maxEntriesPerFolder` subfolders or files. Returns a list of
 * names, where the last one is the file name, all others are folder names.
 * 
 * Example: `distributedFilePath(1003)` results in `['2', '1', '3']` which 
 * could be translated to the file path `2/1/3.json`.
 */
export function distributedFilePath(index: number, maxEntriesPerFolder: number = 1000): string[] {
  if (index < 0)
    throw new Error('Only numbers >= 0 supported')
  const names: string[] = []
  do {
    names.unshift((index % maxEntriesPerFolder).toString())
    index = Math.floor(index / maxEntriesPerFolder)
  } while (index > 0)
  names.unshift(names.length.toString())
  return names
}

Source: zeed Framework

Online Services and Peer-To-Peer

A suitable mix of the database or file system approach can be selected for online services, depending on which is better suited to the selected service. For Dropbox or WebDAV, for example, this would be the file system approach. For Apple CloudKit, the database approach.

But a simple service of your own is also conceivable, with a REST, WebSocket or other useful interfaces.

There is also no reason not to synchronize the data via peer-to-peer (P2P) or another local communication channel. After all, the data is identical and can therefore be synchronized with other clients via the fastest route. Redundancy is therefore an advantage and does not make things any more complicated. Theoretically, the sequence and multiple application of changes is also unproblematic with CRDT.

Refinements

There is still potential for improvement in some areas:

• Control of data size per log entry. Collecting several changes for larger packages or splitting a change into several packages if the scope becomes too large.
• Compression or summarization of data.
• Announcement of new clients, e.g. through special log entries. Evaluation using cryptographic methods.
• By adding a logical clock, such as the Lamport clock, entries can be sorted logically, thereby improving the chronology of an entry.
• Writing the data in a single file per client for reasons of resource optimization.
• Through the clever use of cryptographic means, it may even be possible to implement rights management (Cryptree).

Outlook

I have been using this technique in my apps for several years, for example in the now completed project Onepile. New projects using this approach will be published soon.

Simplicity and flexibility seem to me to be the biggest advantages of this approach. As a result, it should also be future-proof and be able to adapt quickly to new technical conditions.

The following diagram is an example of an ecosystem for a web app:

Related

• Discussion of the article on HackerNews
• Martin Kleppmann’s Talk on the Local-First Conference 2024 in Berlin
• Mastodon comment of Martin Kleppmann
• List of similar approaches:
  • git-bug
  • remotestorage.io
  • Local, first, forever
  • Understanding Delta Lake’s consistency model
  • Data Laced with History: Causal Trees & Operational CRDTs

I recently read about a “massive fake news machine” that the German Foreign Ministry claims to have uncovered (see below). It can hardly be distinguished from legitimate news.

It occurred to me spontaneously that if you are not able to stop manipulated news, you should at least be able to identify legitimate news.

The idea is simple: let’s create a digital network of trust using cryptographic means.

From here it gets technical…

The simplest form of signing is the calculation of a hash values. So let’s assume I want to tweet as @holtwick: “I don’t like fake news!” and my secret would be “Gurkensalat” (usually called “salt”). In the terminal it would go like this:

echo -n "@holtwick I don't like fake news! Gurkensalat" | shasum -a 256

Alternatively with OpenSSL:

echo -n "@holtwick I don't like fake news! Gurkensalat" | openssl dgst -sha256

The result is:

55bc8fe5493377787bfc0be29417fd692070dc8446b855d62a9fedca5b536d53

This can also be calculated before I tweet it. Then I take part of the result, e.g. the first 8 characters, and send it with the message, perhaps with a distinguishing feature such as a preceding ~ character:

Now it’s time to verify something like this. A small service on your own website would be conceivable. Here is a small example in PHP of what an online check could look like:

<?php 

// This one is top secret :)
$salt = "Gurkensalat";

// Normalize whitespace to avoid copy paste issues
$sample = trim(preg_replace('/[\t\n\r\s]+/', ' ', $_GET["text"])) . " " . $salt;

// Calculate SHA256 and only use the first 8 chars
$hash = substr(hash('sha256',  $sample), 0, 8);

// Compare hashes and return result
echo strcmp($_GET["hash"], $hash) == 0 ? "ok" : "invalid";
?>

The resulting URL would then be: https://holtwick.de/experiments/id.php?text=@holtwick%20I%20don%27t%20like%20fake%20news!&hash=55bc8fe5

Try it out:

Ok, that was a relatively primitive implementation to illustrate the idea. For a serious application, other techniques would certainly be used, such as a public key procedure or blockchains. Of course, there are already services that do something similar, as this overview from the Federal Network Agency shows.

Source

• DW (engl.)
• The Guardian (engl.)
• Spiegel (dt.)
• Tagesschau (dt.)

After a few years, it was time to update the website. For the last version, I had even developed my own static website generator called Hostic and everything went wonderfully. But even though I love reinventing the wheel, I only did it halfway for this new attempt.

Basically, this website consists of Vue and Markdown. A static version of this is created so that the corresponding page with content is available for each URL. This allows the website to be easily indexed by search engines and the loading time is very short. The process is called SSG (Server-Side Rendering).

The highlight, however, is that this approach allows dynamic elements to be integrated into the website and even individual posts. A first example is the interactive registration for my e-mail newsletter, because I simply insert <AppNewsletter/> at this point:

Another thing that makes things easier is the use of Obsidian as a Markdown editor for the content. I use this practical tool every day anyway and can thus easily maintain the content.

I derived my own approach from the great project Vitesse. The technique used is almost identical, but I had to make a few adjustments for my purposes.

Last year I started video chat projects. First peer.school with which I wanted to contribute to the education of younger children. Then from that Brie.fi/ng, which focuses on secure communication.

Briefing in particular has found many friends on Github and is now available in several languages, including Chinese and very recently Russian.

The project has a very simple design and uses the Javascript framework Vue. All the necessary functions are available, plus even such exciting features as hiding or swapping a person’s background.

Some native apps are also available, but among them the iOS App with support for AppClips (enter rooms via QR code or NFC transmitter) is especially worth mentioning.

Embedding

Besides sharing a URL to enter a shared room, there is also the possibility to embed Briefing directly into your own website. A simple IFrame makes it possible, like this one:

<iframe
  src="https://brie.fi/ng/cool-call-62?audio=1&video=1&fs=0&invite=0&prefs=0&share=0"
  allow="camera; microphone; fullscreen; speaker; display-capture"
></iframe>

For easy configuration, there is now an IFrame Tool where anyone can quickly configure their code themselves with a few clicks:

If you want to have full control, you can also install all the components that are necessary for operation yourself. Instructions can be found in the README on Github.

Commercial license

Briefing is open source, but under the EUPL v1.2 license, which is a European answer to the GPL. This means that changes have to be published under the same license.

However, if it is desired not to publish changes, it is certainly fair to acquire a commercial license that offers these freedoms. Everything about this can also be found in the README.

Future

Currently I’m working on a third product that should follow in the footsteps of Briefing. The focus is on better scalability, privacy and encryption, and relatime collaboration. The development is already well advanced. More about that soon here…

LanguageTool is the secret weapon for producing error-free texts in different languages. Personally, I’m at war with many a grammar rule and am glad when the machine warns me before it gets embarrassing 😅

However, I believe not everything I wrote needs to be sent to a service that is great, but not under my control.

So here are some tips to set up and use an appropriate server yourself.

Setting up your own server

The easiest way to set up your own server is via Docker. This package offers itself: erikvl87/languagetool. And this is how it is loaded and started:

docker pull erikvl87/languagetool
docker run -d --restart unless-stopped -p 8010:8010 erikvl87/languagetool

Great, now the server can be reached at http://example.com:8010. There is more background information at https://dev.languagetool.org/http-server

Use in Visual Studio Code

The extension LanguageTool Linter provides all necessary functions to work with LanguageTool. Here the server URL can be entered now. The editing of texts and Markdown becomes much more comfortable.

The following adjustments to the settings have proven useful:

{
  "languageToolLinter.external.url": "http://example.com:8010",
  "languageToolLinter.hideDiagnosticsOnChange": true,
  "languageToolLinter.hideRuleIds": true,
  "languageToolLinter.lintOnChange": true,
  "languageToolLinter.lintOnOpen": true
}

Use in Firefox

There are numerous plugins available for browsers and other apps, see https://languagetool.org/#plugins. In the Firefox extension, you can enter your own server under “Experimental settings (only for advanced users)”. The URL must be added to the version path, in our example: http://example.com:8010/v2/.

I love Vue.js from Evan You and I like static websites. Of course there are already solutions to combine these two passions like VuePress or Nuxt. But would I be a programmer if I would choose this simple way?

Of course I wanted to get to the bleeding edge and was quickly inspired by Evans newest coup: vite. It throws the ballast of the webpack overboard and does everything right. First I tried my luck with it and vitepress, but unfortunately that was not quite what I was looking for.

So I took a step back and looked at the classics of static website generation: Gatsby, Hugo, Jekyll and 11ty. They did everything right too, but everything didn’t come off the shelf as I would like it to. Especially since I had already built my own solution for SeaSite, with which all my websites were generated.

What do I want?

But what was it that I wanted? I have found out the following points for me:

1. Speed: I want to make changes in the code like I did with Vue.js and see the result immediately in the browser.
2. Flexibility: I would like to be able to influence every aspect of the code myself and be able to program. Preferably in Javascript.
3. Post processing: I would like to be able to easily adjust content after it has already been calculated. This was the core principle of SeaSite, which allowed me to optimize images and videos afterwards, but also to run translations of text passages for different language versions.

How do I do it?

Well, at point 1 I had already discovered esbuild in vite. It is so incredibly fast that I could not believe it. The result is also reliable and exactly as it should be. esbuild was set as a tool that I wanted to use.

So I first built a small Node.js script that transpiled a Javascript file. I also built a small library to register routes. The generation of the content should be done on-demand when the website is requested by a simple Express.js webserver. To generate the static pages I would simply generate and save the content for all registered routes. This worked great and took only milliseconds.

Quickly I wanted to have the comfort of vite, i.e. when files change, the browser reloads immediately. With Chokidar I could watch the folder with the JS files and recompile everything via esbuild. With a little trick, the import cache of Node.js could be bypassed and the new JS could be loaded and executed. With socket.io a reload mechanism for the browser was quickly assembled.

Now everything should become more beautiful!

I had now finally caught fire and there was no turning back. Then it could also become more beautiful :) Unfortunately I didn’t succeed in integrating Vue.js at the first go, but I also doubted if this would make sense at all. In SeaSite I had already used JSX and JSDOM. For another project I had already written a DOM abstraction, which is very lean. I now extended it in a way that HTML and XML could be generated easily with JSX.

This made it possible to manipulate the content with simple DOM actions. But how much nicer it would be, if the corresponding nodes could be found by CSS selectors. So I also implemented the css-parse and it worked fine.

Also a markdown parser was already available from SeaSite and was only extended to provide meta data for the registration of routes while maintaining the pleasant speed.

Open Source!

So now everything was on board that was needed and it was time to create a simple unified structure to publish the project. A first goal was to describe the routes with simple data structures to get maximum flexibility. For common formats like HTML, XML, JSON, text and assets convenient methods were created.

Since everything had the appearance of a web server anyway, which can also spit out static pages, it was obvious to adopt the smart middleware pattern of Koa.js. This way, templates and plugins are easy to realize. A copy of the data structure mentioned serves then as context and the result is expected in the property ctx.body.

Here it is now, the final project. I would be very happy about help and ideas. Maybe it is not the greatest tool to create static websites, but maybe it is the basis for an even smarter solution that builds on it.

github.com/holtwick/hostic

https://www.npmjs.com/package/hostic

In the coming posts I will further explore some of the issues that arise when creating a website and how they can be solved with Hostic. The list of current ideas on topics:

• Building a simple static website with Hostic
• Building a blog with Markdown
• Building a multilingual website and localization
• Optimizations for search engines and accessibility
• Hosting: Beaker Browser, see…

These websites are already driven by Hostic:

• https://pdfify.app
• https://holtwick.de

Starting point

The most valuable and most successful companies are IT companies: Apple, Google, Amazon and Microsoft. All based in the USA. China, another huge market, is the production site of most hardware, but also the seat of companies that successfully take the place of US companies: Alibaba, Tencent and more. Emerging markets also have their own market, where online business takes place. KaiOS is an example of an innovative model that is hardly known in the first world.

Where does Europe rank? There are no significant online platforms. Businesses and administrations make themselves dependent on software from the USA and hardware from China. Creative entrepreneurs and talented developers are migrating to the USA. In the long run, Europe will become less relevant as an innovator and remain an importer of technology. This is disastrous.

Europe needs a strategy and the political will to change this trend. But the potential and the resources are there to make Europe more independent in a changing global world. In the following I would like to present my personal thoughts on such a strategy.

Data

Europe should under no circumstances try to copy the USA or China. The existing successful solutions are basically centralized solutions. This means that services are offered, where the data of the customers are in the access of the operating companies. No matter how well the privacy promises on the websites can be read, de facto there is no protection of the data from the companies or the authorities of the country where the company is located - usually the USA or China.

Data is the commodity of the information age. The first difference that Europe should make in its strategy is the absolute protection of this data. Users should have full access and control over their data so as not to become dependent on individual companies. This can be achieved through decentralized solutions and strong encryption.

Platform

It must be possible to display and edit data. Computers, tablets, smartphones and, over time, other devices will be used for this purpose. It is important which operating system is used, because this is the foundation on which all solutions are built. Microsoft, Google and Apple have a [monopoly] (https://de.statista.com/themen/783/betriebssysteme/), all of them based in the USA. Europe should focus on its own free platform, with Linux and Android as a first starting point.

But besides the operating system, another secret operating system has emerged: the web browser. Originally a European invention, it has revolutionized the access to information on the Internet. In recent years, complexity has increased and most computer services can now be accessed using web technologies. The programming is easy to learn and the knowledge of it is widely spread. Now with WebAssembly there are no real performance problems anymore.

Europe should take advantage of the fact that there is the proven web platform. However, after the weakening of Firefox only one browser engine is relevant and this is controlled by Google and Apple. Europe should develop its own open engine in the short term, for which Servo is the obvious choice. In the long term the operating system as a whole could be replaced by a web engine, following the example of Google Chrome OS.

Hardware

It is also important to be able to trust the devices themselves. In many chips there are own small operating systems, which take over important functions and normal developers do not have access to the internals. It is important to become more independent in development and production, preferably with an open approach. Why shouldn’t several hardware manufacturers produce the same type of chips? ARM is a successful model in this area. Unfortunately I don’t know enough about this topic to be able to go into more detail. But I think it is important to create a basis that can be trusted and that is not monopolized.

Software

The public sector, i.e. administrations and authorities, should be obliged to use and develop open source software. Any solution developed with government funds must be freely and openly accessible and must be able to be operated without limits and free of license costs. The money currently spent on licenses for Windows in Europe alone should be enough to promote software development. Contracts for development and maintenance should in turn be awarded in Europe in order to stimulate and build up expertise and markets here.

Education

Both education in dealing with IT and the transfer of knowledge through IT should be strengthened. Especially in times of Corona, the deficits have clearly become apparent. The needs for an educational infrastructure are certainly comparable throughout Europe, but there is no common effort to find a solution as far as I know.

In the area of learning materials there are now various solutions, for example in Germany Anton App, Musste Wissen or SimpleClub. But also internationally like Khan Academy. Nevertheless, each teacher prepares his lessons individually and experiences are not effectively shared. A better promotion of such content could improve both traditional and virtual teaching and thus position Europe better, as the level of education increases and becomes more comparable.

Innovation

European citizens have repeatedly shown that they are innovative and recognize future issues. Renewable Energy is a good example of this, but at the same time it is also a bad example of the short breath in political support. In the field of mobility, Europe was at the forefront with fossil fuels by optimizing cars, but then missed out on developments, even though many innovations for the engines of the future also [took place] in Europe [https://de.wikipedia.org/wiki/Transrapid].

The great challenges of our time are also opportunities that must be taken advantage of. The potential is there, now we need the courage and passion to go our own way and to do so as quickly as possible.

Links to similar topics:

• Kommentar: Digitale Souveränität zum Schnäppchenpreis – von Europa und Mozilla by Felix von Leitner, Heise.
• A clean start for the web by Tom MacWright

For every developer there comes the moment where speed matters. It saves you a relevant amount of time and keeps the flow going.

esbuild is definitely fast and reduces the built time significantly. And it is nice and simple too, when it comes to set up.

Build

It can be started from command line or nicely being integrated in a node.js script like this:

const esbuild = require('esbuild')

const options = {
  target: 'node12',
  platform: 'node',
  jsxFactory: 'h',
  jsxFragment: 'hh',
  bundle: true,
  outfile: 'out.js',
  sourcemap: 'inline',
  loader: {
    '.js': 'jsx',
    '.css': 'text',
  },
  entryPoints: [`${sitePath}/index.js`],
}

await service.build(options)

This will build a single JS file containing everything that is needed to run. It also translates JSX and uses the function h to create elements. It also loads files ending on .css as plain text. A source map will be written as well. All this is done in a fragment of a second! This is because esbuild is written in Go instead of Javascript, because speed matters sometimes.

Sitemaps

Speaking of source maps the same author of esbuild also wrote a module to support them on node: node-source-map-support.

Testing

Now the setup is almost complete, but how about testing? I usually use jest for testing and therefore I wanted to get it working here as well. The solutions available did not fit my case, therefore I wrote my own transform:

First make sure to tell Jest what to do in a package.json section:

{
  "jest": {
    "transform": {
      "^.+\\.jsx?$": "./src/jest-transform.js"
    },
    "testEnvironment": "node",
    "testPathIgnorePatterns": [
      "node_modules/",
      "dist/"
    ]
  }
}

The transformer looks like this:

// Inspired by https://github.com/aelbore/esbuild-jest#readme

const fs = require('node:fs')
const esbuild = require('esbuild')
const pkg = require('../package.json')

const external = [
  ...Object.keys(pkg.dependencies ?? {}),
  ...Object.keys(pkg.devDependencies ?? {}),
  ...Object.keys(pkg.peerDependencies ?? {}),
]

module.exports = {

  getCacheKey() { // Forces to ignore Jest cache
    return Math.random().toString()
  },

  process(content, filename) {
    esbuild.buildSync({
      target: 'node14',
      platform: 'node',
      jsxFactory: 'h',
      jsxFragment: 'h',
      bundle: true,
      outfile: 'out-jest.js',
      sourcemap: 'inline',
      loader: {
        '.js': 'jsx',
        '.css': 'text',
      },
      entryPoints: [filename],
      external,
    })
    const js = fs.readFileSync(file, 'utf-8')
    fs.unlinkSync(file)
    return js
  },
}

Competition

Why would you want to you use esbuild and not webpack, babel, rollup, etc.? Well, because it is fast and easy to use. The other solutions are blown up and become pretty complex after a while. They have many 3rd party dependencies, which can cause troubles as well.

If you want to experience the blatant acceleration, then try esbuild.

Photo by Traf on Unsplash