Skip to con­tentGo full –yolo. We’ve got you. LLMs are prob­a­bilis­tic - 1% chance of dis­as­ter makes it a mat­ter of when, not if. Safehouse makes this a 0% chance — en­forced by the ker­nel. Safehouse de­nies write ac­cess out­side your pro­ject di­rec­tory. The ker­nel blocks the syscall be­fore any file is touched. All agents work per­fectly in their sand­boxes, but can’t im­pact any­thing out­side it.Agents in­herit your full user per­mis­sions. Safehouse flips this — noth­ing is ac­ces­si­ble un­less ex­plic­itly granted.Down­load a sin­gle shell script, make it ex­e­cutable, and run your agent in­side it. No build step, no de­pen­den­cies — just Bash and ma­cOS.Safe­house au­to­mat­i­cally grants read/​write ac­cess to the se­lected workdir (git root by de­fault) and read ac­cess to your in­stalled tool­chains. Most of your home di­rec­tory — SSH keys, other re­pos, per­sonal files — is de­nied by the ker­nel.See it fail — proof the sand­box worksTry read­ing some­thing sen­si­tive in­side safe­house. The ker­nel blocks it be­fore the process ever sees the data.# Try to read your SSH pri­vate key — de­nied by the ker­nel

safe­house cat ~/.ssh/id_ed25519

# cat: /Users/you/.ssh/id_ed25519: Operation not per­mit­ted

# Try to list an­other repo — in­vis­i­ble

safe­house ls ~/other-project

# ls: /Users/you/other-project: Operation not per­mit­ted

# But your cur­rent pro­ject works fine

safe­house ls .

# README.md src/ pack­age.json …Add these to your shell con­fig and every agent runs in­side Safehouse au­to­mat­i­cally — you don’t have to re­mem­ber. To run with­out the sand­box, use com­mand claude to by­pass the func­tion.# ~/.zshrc or ~/.bashrc

safe() { safe­house –add-dirs-ro=~/mywork “$@”; }

# Sandboxed — the de­fault. Just type the com­mand name.

claude() { safe claude –dangerously-skip-permissions “$@”; }

codex() { safe codex –dangerously-bypass-approvals-and-sandbox “$@”; }

amp() { safe amp –dangerously-allow-all “$@”; }

gem­ini() { NO_BROWSER=true safe gem­ini –yolo “$@”; }

# Unsandboxed — by­pass the func­tion with `command`

# com­mand claude — plain in­ter­ac­tive ses­sion­Gener­ate your own pro­file with an LLMUse a ready-made prompt that tells Claude, Codex, Gemini, or an­other model to in­spect the real Safehouse pro­file tem­plates, ask about your home di­rec­tory and tool­chain, and gen­er­ate a least-priv­i­lege `sandbox-exec` pro­file for your setup.The guide also tells the LLM to ask about global dot­files, sug­gest a durable pro­file path like ~/.config/sandbox-exec.profile, of­fer a wrap­per that grants the cur­rent work­ing di­rec­tory, and add shell short­cuts for your pre­ferred agents.Open the copy-paste prompt

Ireland to­day (June 20) be­came the 15th coal-free coun­try in Europe, hav­ing ended coal power gen­er­a­tion at its 915 MW Moneypoint coal plant in County Clare. Initially com­mis­sioned in the mid-1980s by ESB, Moneypoint was in­tended to help Ireland off­set the im­pact of the oil crises in the 1970s by pro­vid­ing a de­pend­able source of en­ergy.

But with Ireland now gen­er­at­ing a lot more re­new­able en­ergy nowa­days, coal burn­ing is no longer such an ur­gent need. Energy think tank Ember data states Ireland gen­er­ated 37% (11.4 TWh) of its elec­tric­ity from wind in 2024. Solar is not near wind lev­els of gen­er­a­tion, (0.97 TWh in 2024) but it has been con­tin­u­ously break­ing gen­er­a­tion records in re­cent months and lo­cal stake­hold­ers are con­fi­dent this pos­i­tive trend will con­tinue.

Following the clo­sure, the Moneypoint plant will con­tinue to serve a lim­ited backup role, burn­ing heavy fuel oil un­der emer­gency in­struc­tion from Ireland’s trans­mis­sion sys­tem op­er­a­tor EirGrid un­til 2029.

This strat­egy is in line with pre­vi­ous plans made by EirGrid and ESB to exit coal-fired gen­er­a­tion by the end of 2025, which stip­u­lated that Moneypoint would no longer be ac­tive in the whole­sale elec­tric­ity mar­ket.

“Ireland has qui­etly rewrit­ten its en­ergy story, re­plac­ing toxic coal with home­grown re­new­able power,” said Alexandru Mustață, cam­paigner on coal and gas at Europe’s Beyond Fossil Fuels.

“But this is­n’t ‘job done’. The gov­ern­men­t’s pri­or­ity now must be build­ing a power sys­tem for a re­new­able fu­ture; one with the stor­age, flex­i­bil­ity, and grid in­fra­struc­ture needed to run fully on clean, do­mes­tic re­new­able elec­tric­ity,” Mustață warned.

Jerry Mac Evilly, Campaigns Director at Friends of the Earth Ireland, ap­pealed to the gov­ern­ment to en­sure oil backup at Moneypoint is kept to an ab­solute min­i­mum and ul­ti­mately de­com­mis­sioned. He also ap­pealed for the gov­ern­ment to pre­vent fur­ther de­vel­op­ment of data cen­ters, which he said are in­creas­ing Ireland’s re­liance on fos­sil gas.

“We also can’t ig­nore that the gov­ern­ment is tar­get­ing the in­stal­la­tion of at least 2 GW of gas power plants with no strat­egy to re­duce Ireland’s dan­ger­ous gas de­pen­dency,” he added.

On a broader level, Ireland’s step to close coal power gen­er­a­tion at Moneypoint sets a prece­dent for fur­ther European coun­tries’ coal ex­its to come, says Beyond Fossil Fuels. The group tracks European coun­tries’ progress on their com­mit­ments to switch­ing from fos­sil fu­els to re­new­able en­ergy. So far, 23 European coun­tries have com­mit­ted to coal phase-outs. Italy is ex­pected to com­plete its main­land coal phase-out this sum­mer with the up­com­ing clo­sure of its last two big coal power plants, while main­land Spain is also ex­pect­ing to de­clare it­self coal-free this sum­mer.

Based on its own char­ter, OpenAI should sur­ren­der the race

We are con­cerned about late-stage AGI de­vel­op­ment be­com­ing a com­pet­i­tive race with­out time for ad­e­quate safety pre­cau­tions. Therefore, if a value-aligned, safety-con­scious pro­ject comes close to build­ing AGI be­fore we do, we com­mit to stop com­pet­ing with and start as­sist­ing this pro­ject. We will work out specifics in case-by-case agree­ments, but a typ­i­cal trig­ger­ing con­di­tion might be “a bet­ter-than-even chance of suc­cess in the next two years.”

Interestingly, this is still hosted at https://​ope­nai.com/​char­ter/, mean­ing it re­mains the of­fi­cial com­pany pol­icy.

At the same time, ex­plic­itly stated AGI time­lines by Sam Altman are the fol­low­ing:

“Within the next ten years, AI sys­tems will ex­ceed ex­pert skill level in most do­mains”

“By the time the end of this decade rolls around, the world will be in an un­be­liev­ably bet­ter place”

“I think in 5 years […] peo­ple are like, man, the AGI mo­ment came and went”

“What are you ex­cited about in 2025? - AGI”

“AGI will prob­a­bly get de­vel­oped dur­ing Trump’s term”

“By 2030, if we don’t have ex­tra­or­di­nar­ily ca­pa­ble mod­els that do things we can’t, I’d be very sur­prised”

“AGI kinda went whoosh­ing by… okay fine, we built AGIs”

“We ba­si­cally have built AGI” (later: “a spir­i­tual state­ment, not a lit­eral one”)

We can see that the time­line of AGI (let’s as­sume this is the time­line for a bet­ter-than-even chance) has ac­cel­er­ated and the me­dian pre­dic­tion since 2025 is around 2 years. Notably, in the lat­est in­ter­views it’s claimed that AGI has been achieved, and we’re now rac­ing to­wards ASI.

Finally, here’s a snap­shot of the cur­rent over­all Arena rank­ing of top 10 mod­els.

Based on these, the flag­ship GPT-5.4 model is clearly trail­ing be­hind com­pe­ti­tion. At least Anthropic’s and Google’s mod­els are clearly safety-con­scious, and prob­a­bly value-aligned (whatever that means, but since the mod­els are drop-in re­place­ments to GPT, it should hold).

It can be de­bated whether arena.ai is a suit­able met­ric for AGI, a strong case can prob­a­bly be made for why it’s not. However, that’s ir­rel­e­vant, as the spirit of the self-sac­ri­fice clause is to avoid an arms race, and we are clearly in one.

Therefore, one can only con­clude, that we cur­rently meet the stated ex­am­ple trig­ger­ing con­di­tion of “a bet­ter-than-even chance of suc­cess in the next two years”. As per its char­ter, OpenAI should stop com­pet­ing with the likes of Anthropic and Gemini, and join forces, how­ever that might look like.

While this will never hap­pen, I think it’s il­lus­tra­tive of some great points for pon­der­ing:

The im­po­tence of naive ide­al­ism in the face of eco­nomic in­cen­tives.

The dis­crep­ancy be­tween mar­ket­ing points and prac­ti­cal ac­tions.

The chang­ing goal­posts of AGI and time­lines. Notably, it’s com­mon to now talk about ASI in­stead, im­ply­ing we may have al­ready achieved AGI, al­most with­out notic­ing.

We’re pleased to an­nounce the re­lease of LibreOffice 26.2, the newest ver­sion of the free and open source of­fice suite trusted by mil­lions of users around the world. This re­lease makes it eas­ier than ever for users to cre­ate, edit and share doc­u­ments on their own terms. Designed for in­di­vid­u­als and or­ga­ni­za­tions alike, it con­tin­ues to be a trusted al­ter­na­tive to pro­pri­etary of­fice soft­ware.

LibreOffice 26.2 is fo­cused on im­prove­ments that make a dif­fer­ence in daily work and brings bet­ter per­for­mance, smoother in­ter­ac­tion with com­plex doc­u­ments and im­proved com­pat­i­bil­ity with files cre­ated in other of­fice soft­ware. Whether you’re writ­ing re­ports, man­ag­ing spread­sheets, or prepar­ing pre­sen­ta­tions, the ex­pe­ri­ence feels more re­spon­sive and re­li­able.

LibreOffice has al­ways been about giv­ing users con­trol. LibreOffice 26.2 con­tin­ues that tra­di­tion by strength­en­ing sup­port for open doc­u­ment stan­dards, and en­sur­ing long-term ac­cess to your files, with­out sub­scrip­tions, li­cense re­stric­tions, or data col­lec­tion. Your doc­u­ments stay yours — for­ever.

Behind this re­lease there is a global com­mu­nity of con­trib­u­tors. Developers, de­sign­ers, trans­la­tors, QA testers, and vol­un­teers from around the world worked to­gether to de­liver hun­dreds of fixes and re­fine­ments. Their ef­forts re­sult in a suite that not only adds fea­tures, but also im­proves qual­ity, con­sis­tency, and sta­bil­ity, re­lease af­ter re­lease.

* Improved per­for­mance and re­spon­sive­ness across the suite, mak­ing large doc­u­ments open, edit, and save more smoothly.

* Enhanced com­pat­i­bil­ity with doc­u­ments cre­ated in pro­pri­etary and open core of­fice soft­ware, re­duc­ing for­mat­ting is­sues and sur­prises.

* Hundreds of bug fixes and sta­bil­ity im­prove­ments con­tributed by the global LibreOffice com­mu­nity.

See the Release Notes for the full list of new fea­tures.

Florian Effenberger, Executive Director of The Document Foundation, says:

LibreOffice 26.2 shows what hap­pens when soft­ware is built around users, not busi­ness mod­els, and how open source soft­ware can de­liver a mod­ern, pol­ished pro­duc­tiv­ity suite with­out com­pro­mis­ing user free­dom. This re­lease is about speed, re­li­a­bil­ity, and giv­ing peo­ple con­trol over their doc­u­ments.

LibreOffice 26.2 is avail­able for Windows, ma­cOS, and Linux, and sup­ports over 120 lan­guages out of the box. It can be used at home, in busi­nesses, schools, and pub­lic in­sti­tu­tions, with no li­cens­ing fees and no ven­dor lock-in.

You can down­load LibreOffice 26.2 to­day from the of­fi­cial LibreOffice web­site. We in­vite users to try the new re­lease, share feed­back, and join the com­mu­nity help­ing shape the fu­ture of LibreOffice. If they are happy, they can do­nate to sup­port the in­de­pen­dence and the fu­ture de­vel­op­ment of the pro­ject.

About LibreOffice and The Document Foundation

LibreOffice is a free, pri­vate and open source of­fice suite used by mil­lions of peo­ple, busi­nesses, and pub­lic in­sti­tu­tions world­wide. It is de­vel­oped by an in­ter­na­tional com­mu­nity and sup­ported by The Document Foundation, an in­de­pen­dent non-profit or­ga­ni­za­tion that pro­motes open stan­dards, dig­i­tal sov­er­eignty and user choice.

How I re­pur­posed my old gam­ing PC to set up a home server for data stor­age, back­ups, and self-hosted apps.

How I re­pur­posed my old gam­ing PC to set up a home server for data stor­age, back­ups, and self-hosted apps.

For the longest time, I’ve pro­cras­ti­nated on find­ing a good backup and stor­age so­lu­tion for my Fujifilm RAW files. My so­lu­tion up un­til re­cently in­volved man­u­ally copy­ing my pho­tos across two ex­ter­nal SSD dri­ves. This was quite a has­sle and I had­n’t yet fig­ured out a good off-site backup strat­egy.

After hear­ing con­stant news up­dates of how hard drive prices have been surg­ing due to AI data cen­ter build­outs, I fi­nally de­cided to pur­chase some hard dri­ves and set up a home­lab to meet my stor­age and backup needs. I also used this op­por­tu­nity to ex­plore self-host­ing some apps I’ve been ea­ger to check out.

I re­pur­posed my old gam­ing PC I built back in 2018 for this use case. This ma­chine has the fol­low­ing specs:

I pur­chased the Western Digital hard dri­ves over the win­ter hol­i­day break. The other com­po­nents were al­ready in­stalled on the ma­chine when I orig­i­nally built it.

On this ma­chine I in­stalled TrueNAS Community Edition on my NVMe drive. It’s a Linux-based op­er­at­ing sys­tem that is well-tai­lored for net­work-at­tached stor­age (NAS), file stor­age that is ac­ces­si­ble to any de­vice on your net­work.

For in­stance, TrueNAS al­lows you to cre­ate snap­shots of your data. This is great for pre­vent­ing data loss. If, for ex­am­ple, you ac­ci­den­tally deleted a file, you could re­cover it from a pre­vi­ous snap­shot con­tain­ing that file. In other words, a file is only truly deleted if and only if the sys­tem has no snap­shots con­tain­ing that file.

I’ve set up my ma­chine to take hourly, daily, and even weekly snap­shots. I’ve also con­fig­ured it to delete old snap­shots af­ter a given pe­riod of time to save stor­age space.

Most of my data is mir­rored across the two 8 TB hard disks in a RAID 1 setup. This means that if one drive fails, the other drive will still have all of my data in­tact. The SSD is used to store data from ser­vices that I self-host that ben­e­fit from hav­ing fast read and write speeds.

Not only is TrueNAS good for file stor­age, you can also host apps on it!

TrueNAS of­fers a cat­a­log of apps, sup­ported by the com­mu­nity, that you can in­stall on your ma­chine.

Scrutiny is a web dash­board for mon­i­tor­ing the health of your stor­age dri­ves. Hard dri­ves and SSDs have built-in firmware called S. M.A.R.T. (Self-Monitoring, Analysis, and Reporting Technology) that con­tin­u­ously tracks health met­rics like tem­per­a­ture, power-on hours, and read er­rors.

Scrutiny reads this data and pre­sents it in a dash­board show­ing his­tor­i­cal trends, mak­ing it easy to spot warn­ing signs that a drive may fail soon.

Backrest is a web fron­tend for restic, a com­mand-line tool used for cre­at­ing file back­ups. I’ve set this up to save daily back­ups of my data to an ob­ject stor­age bucket on Backblaze B2.

Immich is one of the most pop­u­lar open-source self-hosted apps for man­ag­ing pho­tos and videos. I love that it also of­fers iOS and Android apps that al­low you to back up pho­tos and videos from your mo­bile de­vices. This is great if you want to rely less on ser­vices like Google Photos or iCloud. I’m cur­rently us­ing this to back up pho­tos and videos from my phone.

Mealie is a recipe man­age­ment tool that has made my meal prep­ping ex­pe­ri­ence so much bet­ter! I’ve found it great for sav­ing recipes I find on sites like NYT Cooking.

When im­port­ing recipes, you can pro­vide the URL of the recipe and Mealie will scrape the in­gre­di­ents and in­struc­tions from the page and save it in your recipe li­brary. This makes it eas­ier to keep track of recipes you find on­line and want to try out later.

Ollama is a back­end for run­ning var­i­ous AI mod­els. I in­stalled it to try run­ning large lan­guage mod­els like qwen3.5:4b and gem­ma3:4b out of cu­rios­ity. I’ve also re­cently been ex­plor­ing the world of vec­tor em­bed­dings such as qwen3-em­bed­ding:4b. All of these mod­els are small enough to fit in the 8GB of VRAM my GPU pro­vides. I like be­ing able to of­fload the work of run­ning mod­els on my home­lab in­stead of my lap­top.

When I’m not at home, I use Tailscale, a plug-and-play VPN ser­vice, to ac­cess my data and self-hosted apps re­motely from any de­vice. Tailscale builds on top of an­other tool called WireGuard to pro­vide a se­cure tun­nel into my home net­work.

The ad­van­tage here is that my home­lab PC does­n’t need to be ex­posed to the pub­lic in­ter­net for this to work. Any de­vice I want to use to ac­cess my home­lab re­motely needs to in­stall the Tailscale app and be au­then­ti­cated to my Tailscale net­work.

Right now, ac­cess­ing my apps re­quires typ­ing in the IP ad­dress of my ma­chine (or Tailscale ad­dress) to­gether with the ap­p’s port num­ber. Because all of my ser­vices share the same IP ad­dress, my pass­word man­ager has trou­ble dis­tin­guish­ing which lo­gin to use for each one.

In the fu­ture I’ll look into fig­ur­ing out how to as­sign cus­tom do­main names to all of my ser­vices.

ShadowBroker is a real-time, multi-do­main OSINT dash­board that ag­gre­gates live data from dozens of open-source in­tel­li­gence feeds and ren­ders them on a uni­fied dark-ops map in­ter­face. It tracks air­craft, ships, satel­lites, earth­quakes, con­flict zones, CCTV net­works, GPS jam­ming, and break­ing geopo­lit­i­cal events — all up­dat­ing in real time.

Built with Next.js, MapLibre GL, FastAPI, and Python, it’s de­signed for an­a­lysts, re­searchers, and en­thu­si­asts who want a sin­gle-pane-of-glass view of global ac­tiv­ity.

git clone https://​github.com/​Big­Body­Cobain/​Shad­ow­bro­ker.git

cd Shadowbroker

docker-com­pose up -d

* Carrier Strike Group Tracker — All 11 ac­tive US Navy air­craft car­ri­ers with OSINT-estimated po­si­tions

* Clustered Display — Ships clus­ter at low zoom with count la­bels, declus­ter on zoom-in

* Region Dossier — Right-click any­where on the map for:

The repo in­cludes a docker-com­pose.yml that builds both im­ages lo­cally.

git clone https://​github.com/​Big­Body­Cobain/​Shad­ow­bro­ker.git

cd Shadowbroker

# Add your API keys (optional — see Environment Variables be­low)

cp back­end/.​env.ex­am­ple back­end/.​env

# Build and start

docker-com­pose up -d –build

Custom ports or LAN ac­cess? The fron­tend auto-de­tects the back­end at

. If you remap the back­end to a dif­fer­ent port (e.g. “9096:8000”), set NEXT_PUBLIC_API_URL be­fore build­ing:

NEXT_PUBLIC_API_URL=http://​192.168.1.50:9096 docker-com­pose up -d –build

This is a build-time vari­able (Next.js lim­i­ta­tion) — it gets baked into the fron­tend dur­ing npm run build. Changing it re­quires a re­build.

If you just want to run the dash­board with­out deal­ing with ter­mi­nal com­mands:

Go to the Releases tab on the right side of this GitHub page.

Download the lat­est .zip file from the re­lease.

Extract the folder to your com­puter.

It will au­to­mat­i­cally in­stall every­thing and launch the dash­board!

If you want to mod­ify the code or run from source:

* Python 3.10, 3.11, or 3.12 with pip — python.org (check “Add to PATH” dur­ing in­stall)

Python 3.13+ may have com­pat­i­bil­ity is­sues with some de­pen­den­cies. 3.11 or 3.12 is rec­om­mended.

* Python 3.13+ may have com­pat­i­bil­ity is­sues with some de­pen­den­cies. 3.11 or 3.12 is rec­om­mended.

# Clone the repos­i­tory

git clone https://​github.com/​your-user­name/​shad­ow­bro­ker.git

cd shad­ow­bro­ker/​live-risk-dash­board

# Backend setup

cd back­end

python -m venv venv

venv\Scripts\ac­ti­vate # Windows

# source venv/​bin/​ac­ti­vate # ma­cOS/​Linux

pip in­stall -r re­quire­ments.txt

# Create .env with your API keys

echo “AIS_API_KEY=your_aisstream_key” >> .env

echo “OPENSKY_CLIENT_ID=your_opensky_client_id” >> .env

echo “OPENSKY_CLIENT_SECRET=your_opensky_secret” >> .env

# Frontend setup

cd ../frontend

npm in­stall

# From the fron­tend di­rec­tory — starts both fron­tend & back­end con­cur­rently

npm run dev

All lay­ers are in­de­pen­dently tog­gleable from the left panel:

The plat­form is op­ti­mized for han­dling mas­sive real-time datasets:

* Viewport Culling — Only fea­tures within the vis­i­ble map bounds (+20% buffer) are ren­dered

* Clustered Rendering — Ships, CCTV, and earth­quakes use MapLibre clus­ter­ing to re­duce fea­ture count

# Required

AIS_API_KEY=your_aisstream_key # Maritime ves­sel track­ing (aisstream.io)

# Optional (enhances data qual­ity)

OPENSKY_CLIENT_ID=your_opensky_client_id # OAuth2 — higher rate lim­its for flight data

OPENSKY_CLIENT_SECRET=your_opensky_secret # OAuth2 — paired with Client ID above

LTA_ACCOUNT_KEY=your_lta_key # Singapore CCTV cam­eras

This is an ed­u­ca­tional and re­search tool built en­tirely on pub­licly avail­able, open-source in­tel­li­gence (OSINT) data. No clas­si­fied, re­stricted, or non-pub­lic data sources are used. Carrier po­si­tions are es­ti­mates based on pub­lic re­port­ing. The mil­i­tary-themed UI is purely aes­thetic.

Do not use this tool for any op­er­a­tional, mil­i­tary, or in­tel­li­gence pur­pose.

This pro­ject is for ed­u­ca­tional and per­sonal re­search pur­poses. See in­di­vid­ual API provider terms of ser­vice for data us­age re­stric­tions.

Built with ☕ and too many API calls

FontCrafter turns your hand­writ­ing into a real, in­stal­lable font — en­tirely in your browser. No ac­counts, no up­loads to servers, no cost.

Still have ques­tions? Here’s our FAQ.

It’s eas­ier than you think. Print, write, scan — done.

Your hand­writ­ing be­comes an in­stal­lable font (OTF, TTF, WOFF2, Base64)

Natural vari­a­tion — your let­ters won’t look ro­botic or iden­ti­cal every time

Connected let­ter pairs (ff, th, st, etc.) that flow like real hand­writ­ing

Works in Word, Pages, Photoshop, web­sites — every­where fonts are used

No ac­count, no server, 100% pri­vate — every­thing hap­pens in your browser

If you found this use­ful, I’d ap­pre­ci­ate do­na­tions & pa­trons (to keep it­er­at­ing)!

Download and print the tem­plate — US Letter or A4.

Print at 100% scale (no “fit to page”). Use white, un­lined pa­per.

Fill in every box with a felt-tip pen. All 3 rows for each char­ac­ter.

Ballpoints are too faint; thick mark­ers bleed. Keep strokes in­side the boxes with breath­ing room from edges.

How to use the three rows: Row 1 is al­ways up­per­case. Row 2 can be a sec­ond ver­sion of your up­per­case or low­er­case. Row 3 can also be up­per­case or low­er­case.

Scan or pho­to­graph the sheet, then drag & drop that photo file be­low.

Lay the sheet flat on a table with even light­ing — no shad­ows, no curl. A phone cam­era works great if the sheet is flat and well-lit.

Drop your com­pleted (scanned) im­age be­low. JPG, PNG, or high-res photo — make sure the page is flat and evenly lit. The pro­cess­ing hap­pens on your end. No servers in­volved. Nothing is saved or stored re­motely.

Drop your filled-in scan here, or click to browse

Not happy with a char­ac­ter? Touch it up in any im­age ed­i­tor, or use cor­rec­tion tape and re-scan.

Ensure All Four Crosshair Markers Are Visible and Continue →

Characters with green bor­ders were de­tected cleanly. Click any char­ac­ter to de­s­e­lect it — a re­place­ment from an­other row will be used. Small im­per­fec­tions are fine — they give your font per­son­al­ity.

Name your font and choose how your three rows should be used. Enable lig­a­tures for nat­ural-look­ing con­nected let­ter pairs.

What do you want to call this font?

What did you put in each row?

I wrote up­per­case in all three rows

I wrote up­per­case in Row 1, low­er­case in Row 2, up­per­case in Row 3

I wrote up­per­case in Row 1, low­er­case in Row 2, low­er­case in Row 3

Row 2 will be used as your low­er­case. Adjust how much to shrink it — set to 1.00 if you al­ready wrote Row 2 smaller than Row 1.

Allow cer­tain char­ac­ters to dip be­low the base­line (e.g. g, j, p, q, y, or a slashed zero).

Separate with spaces. Add or re­move char­ac­ters as needed for your hand­writ­ing.

Controls how far de­scen­der tails drop be­low the line. Slide left for deeper, right for shal­lower.

Cleans up tiny ink specks that bled through from ad­ja­cent cells. Won’t af­fect dots on let­ters like i, j, or punc­tu­a­tion marks.

Evens out let­ters that were drawn at dif­fer­ent sizes.

Adds 100+ de­rived glyphs from your hand­writ­ing. Uncheck if you only want your hand­writ­ten al­phanu­meric char­ac­ters.

Auto-generates di­a­crit­ics (accents, tildes, um­lauts) from your base let­ters. Covers French, German, Spanish, Portuguese, Scandinavian, and more.

Ligatures are let­ter pairs that con­nect nat­u­rally in hand­writ­ing — like ff, fi, fl, th, and st. Auto-generate is rec­om­mended — it’s in­stant and pro­duces nat­ural-look­ing con­nec­tions from your ex­ist­ing char­ac­ters.

Kerning ad­justs spac­ing be­tween spe­cific let­ter pairs — like AV, To, and WA — so char­ac­ters with com­ple­men­tary shapes sit to­gether nat­u­rally in­stead of hav­ing uni­form gaps.

See how your font looks with sam­ple text, or type any­thing you like be­low.

THE QUICK BROWN FOX JUMPS OVER A LAZY DOG.

sphinx of black quartz, judge my vow?

Both Fickle Dwarves Can Jinx My Pig Quiz!

• $11.38 + tax & a 5.69% tip = more than $20.74

• (I love Star Wars) [Yes] {Maybe} <OK>

• That’s what I said! “Really?”

• ar­cade.pir­illo.com * chris.pir­illo.com

• He scored 7/8 on the quiz — not bad~

• Order #4053: 2x @$16.99 each | Total: $33.98

• Is it _really_ 100^2 = 10,000‽

• “Yes,” she said, ‘it’s a go;’ then walked away.

Your font in­cludes con­tex­tual al­ter­nates (calt) — con­sec­u­tive char­ac­ters will au­to­mat­i­cally cy­cle be­tween your 3 hand­writ­ing vari­ants. This works in apps with OpenType sup­port but may not ap­pear in this pre­view.

Click here to try it for your­self…

If you found this use­ful, I’d ap­pre­ci­ate do­na­tions & pa­trons (to keep it­er­at­ing)!

OTF for desk­top apps, TTF for uni­ver­sal com­pat­i­bil­ity, WOFF2 for web­sites, Base64 for CSS em­bed­ding.

I con­firm that the hand­writ­ing used to gen­er­ate this font is my own or I have ex­plicit per­mis­sion from the hand­writ­ing’s owner to cre­ate and use this font. I un­der­stand that I am solely re­spon­si­ble for how I use the gen­er­ated font files, and I re­lease FontCrafter, Chris Pirillo, LockerGnome, and ar­cade.pir­illo.com from any li­a­bil­ity re­lated to the font’s cre­ation, dis­tri­b­u­tion, or use.

Literate pro­gram­ming is the idea that code should be in­ter­min­gled with prose such that an un­in­formed reader could read a code base as a nar­ra­tive, and come away with an un­der­stand­ing of how it works and what it does.

Although I have long been in­trigued by this idea, and have found uses for it in a cou­ple of dif­fer­ent cases, I have found that in prac­tice lit­er­ate pro­gram­ming turns into a chore of main­tain­ing two par­al­lel nar­ra­tives: the code it­self, and the prose. This has ob­vi­ously lim­ited its adop­tion.

Historically in prac­tice lit­er­ate pro­gram­ming is most com­monly found as Jupyter note­books in the data sci­ence com­mu­nity, where ex­pla­na­tions live along­side cal­cu­la­tions and their re­sults in a web browser.

Frequent read­ers of this blog will be aware that Emacs Org Mode sup­ports poly­glot lit­er­ate pro­gram­ming through its org-ba­bel pack­age, al­low­ing ex­e­cu­tion of ar­bi­trary lan­guages with re­sults cap­tured back into the doc­u­ment, but this has re­mained a niche pat­tern for nerds like me.

Even for some­one as en­thu­si­as­tic about this pat­tern as I am, it be­comes cum­ber­some to use Org as the source of truth for larger soft­ware pro­jects, as the source code es­sen­tially be­comes a com­piled out­put, and af­ter every edit in the Org file, the code must be re-ex­tracted and placed into its des­ti­na­tion (“tangled”, in Org Mode par­lance). Obviously this can be au­to­mated, but it’s easy to get into an­noy­ing sit­u­a­tions where you or your agent has edited the real source and it gets over­writ­ten on the next tan­gle.

That said, I have had enough suc­cess with us­ing lit­er­ate pro­gram­ming for book­keep­ing per­sonal con­fig­u­ra­tion that I have not been able to fully give up on the idea, even be­fore the ad­vent of LLMs.

For ex­am­ple: be­fore cod­ing agents, I had been adapt­ing a pat­tern for us­ing Org Mode for man­ual test­ing and note-tak­ing: in­stead of work­ing on the com­mand line, I would write more com­mands into my ed­i­tor and ex­e­cute them there, edit­ing them in place un­til each step was cor­rect, and run­ning them in-place, so that when I was done I would have a doc­u­ment ex­plain­ing ex­actly the steps that were taken, with­out ex­tra steps or note-tak­ing. Combining the act of cre­at­ing the note and run­ning the test gives you the notes for free when the test is com­pleted.

This is even more ex­cit­ing now that we have cod­ing agents. Claude and Kimi and friends all have a great grasp of Org Mode syn­tax; it’s a for­giv­ing markup lan­guage and they are quite good at those. All the doc­u­men­ta­tion is avail­able on­line and was prob­a­bly in the train­ing data, and while a big down­side of Org Mode is just how much syn­tax there is, but that’s no prob­lem at all for a lan­guage model.

Now when I want to test a fea­ture, I ask the clanker to write me a run­book in Org. Then I can re­view it — the prose ex­plains the mod­el’s re­flec­tion of the in­tent for each step, and the code blocks are in­ter­ac­tively ex­e­cutable once I am done re­view­ing, ei­ther one at a time or the whole file like a script. The re­sults will be stored in the doc­u­ment, un­der the code, like a Jupyter note­book.

I can edit the prose and ask the model to up­date the code, or edit the code and have the model re­flect the mean­ing upon the text. Or ask the agent to change both si­mul­ta­ne­ously. The prob­lem of main­tain­ing the par­al­lel sys­tems dis­ap­pears.

The agent is told to han­dle tan­gling, and the prob­lem of ex­trac­tion goes away. The agent can be in­structed with an AGENTS.md file to treat the Org Mode file as the source of truth, to al­ways ex­plain in prose what is go­ing on, and to tan­gle be­fore ex­e­cu­tion. The agent is very good at all of these things, and it never gets tired of re-ex­plain­ing some­thing in prose af­ter a tweak to the code.

The fun­da­men­tal ex­tra la­bor of lit­er­ate pro­gram­ming, which I be­lieve is why it is not widely prac­ticed, is elim­i­nated by the agent and it uti­lizes ca­pa­bil­i­ties the large lan­guage model is best at: trans­la­tion and sum­ma­riza­tion.

As a ben­e­fit, the code base can now be ex­ported into many for­mats for com­fort­able read­ing. This is es­pe­cially im­por­tant if the pri­mary role of en­gi­neers is shift­ing from writ­ing to read­ing.

I don’t have data to sup­port this, but I also sus­pect that lit­er­ate pro­gram­ming will im­prove the qual­ity of gen­er­ated code, be­cause the prose ex­plain­ing the in­tent of each code block will ap­pear in con­text along­side the code it­self.

I have not per­son­ally had the op­por­tu­nity to try this pat­tern yet on a larger, more se­ri­ous code­base. So far, I have only been us­ing this work­flow for test­ing and for doc­u­ment­ing man­ual processes, but I am thrilled by its ap­pli­ca­tion there.

I also rec­og­nize that the Org for­mat is a lim­it­ing fac­tor, due to its tight in­te­gra­tion with Emacs. However, I have long be­lieved that Org should es­cape Emacs. I would pro­mote some­thing like Markdown in­stead, how­ever Markdown lacks the abil­ity to in­clude meta­data. But as usual in my posts about Emacs, it’s not Emacs’s spe­cific im­ple­men­ta­tion of the idea that ex­cites me, as in this case Org’s im­ple­men­ta­tion of lit­er­ate pro­gram­ming does.

It is the idea it­self that is ex­cit­ing to me, not the tool.

With agents, does it be­come prac­ti­cal to have large code­bases that can be read like a nar­ra­tive, whose prose is kept in sync with changes to the code by tire­less ma­chines?

AngstromIO is one of the small­est de­vboards out there, barely longer than a USB-C con­nec­tor, based on the Attiny1616 MCU. 2 GPIOs as well as I2C lines are bro­ken out. I made a dual CH340 pro­gram­ming board too, both for UPDI pro­gram­ming and de­bug­ging (one way Serial Communication). I also de­signed a bread­board friendly, ex­per­i­men­ta­tion board for the CH32V003, with a 4 by 5 char­lieplexed LED ma­trix.

While the AngstromIO is a tiny de­vboard, yet pow­er­ful, that could be em­bbe­ded in any space con­strained pro­jects, the CH32 de­vboard is more an ex­per­i­men­ta­tion board, for me to learn how to pro­gram this awe­some chip on the MounriverStudio pro­gram­ming and how to pro­gram a char­lieplexed ma­trix. The Programmer is an all in one mod­ule, that will make de­bug­ging with the Serial mon­i­tor while pro­gram­ming easy: one board for both.

* One of the small­est de­vboards: 8.9mm by 9mm, USB-C in­cluded

* Attiny1616 MCU, 16Kb flash, low power, ar­duino com­pat­i­ble (for ba­sic li­braries at least)

* Pins bro­ken out: SCL, SDA, PB2 (TX), PA3, +5V, GND, and UPDI for pro­gram­ming

* Dual CH340E setup:

One for pro­gram­ming (set as SerialUPDI pro­gram­mer),

One for de­bug­ging (Serial Communication, USB to UART)

* One for pro­gram­ming (set as SerialUPDI pro­gram­mer),

* One for de­bug­ging (Serial Communication, USB to UART)

* 2 USB-C for data trans­fer, only the USB-C for Serial pro­vides 5V to the board

* USB-C for power, the CH32 runs at 3.3V but PC6 and PC5 are 5V tol­er­ant

Arduino com­pat­i­ble, some li­braries may not work, but some have been arranged/​made by SpenceKonde like Wire (I2C) and tiny­NeoPixel (for more in­for­ma­tion, see: https://​github.com/​SpenceKonde/​megaTiny­Core/​tree/​mas­ter/​megaavr/​li­braries)

PCB de­signed in EasyEDA Pro, 2 lay­ers, 1.0mm thick, Purple sol­der­mask All 3 de­signs pan­el­ized into one PCB.

🚧 to be con­tin­ued…