Drop #622 (2025-03-17): Monday Morning Grab Bag
Might As Well Plonk; Notetaking Just Comes Nash-ually For Some; The Arc Of The Universe Bends Towards Ad Blocking
I really wanted to post all this yesterday, since we need all the good news/distractions we can get these days.
TL;DR
(This is an AI-generated summary of today’s Drop using Ollama + llama 3.2 and a custom prompt.)
- Plonk.li is a new gist/pastebin service built on the ATproto network, storing pastes directly in a Personal Data Server (PDS) as records discoverable through ATproto collection queries. (plonk.li/)
- Nash is a portable, web-based note-taking application that runs entirely in your browser, allowing you to create, edit, and save notes as HTML files with no server dependencies. (keepworking.github.io/nash/)
- Arc Browser has integrated an ad blocker that bypasses Manifest V3 restrictions and aligns with its clean interface philosophy, though it currently lacks features like an allow list and quick disable option.
Might As Well Plonk
So much is happening in ATproto land!
The folks that brought us Tangled are back with Plonk.li (knot) — a gist/pastebin service built on the ATproto network, the same protocol that powers Bluesky. Unlike traditional pastebins that store content on their own servers, Plonk leverages the distributed nature of ATProto by storing pastes directly in a Personal Data Server (PDS). By default, it uses Bluesky’s PDS.
The service is available at plonk.li/ and was developed by @oppili.bsky.social as detailed on their Tangled profile. What makes this particularly interesting is that it’s written using Pug, a template engine for Node.js that offers a cleaner, more concise syntax for generating HTML.
When you create a paste on Plonk, it’s stored as a record in the ATproto network using a custom record type: li.plonk.paste. This means your pastes become part of your ATproto identity and can be discovered through ATproto collection queries.
Looking at my own ATProto collections (at did:plc:hgyzg2hn6zxpqokmp5c2xrdo), you can see various record types including the standard Bluesky ones like app.bsky.feed.post and custom ones like li.plonk.paste.
Drilling down into a specific paste record reveals its structure:
{ "code": "Pastebin on ATproto", "lang": "plaintext", "$type": "li.plonk.paste", "title": "First Post!", "shortUrl": "Hc", "createdAt": "2025-03-16T16:10:36.637Z"}
The record contains the paste content, language for syntax highlighting, title, a short URL for easy sharing, and creation timestamp. This data is stored in the Bluesky PDS at porcini.us-east.host.bsky.network for my account.
If you want to run your own Plonk.li instance, the process is straightforward:
- Clone the repository:
git clone https://tangled.sh/@oppili.bsky.social/plonkli cd plonkli - Install dependencies:
npm install npm install -g tsx pino-pretty npm run build - Create this systemd service file at
~/.config/systemd/user/plonk.service - Set up a reverse proxy with Caddy to expose your service to the internet.
Note that the example service file uses nvm for Node.js version management. In a production environment, make better life choices than I have. And, you can try out my Plonk instance at https://paste.hrbrmstr.app/. I should note that some state/session and paste metadata for anyone that OAuthed to Blusky via a hosted Plonk instance is stored on said Plonk instance.
The integration of a gist/pastebin service with ATproto demonstrates the protocol’s flexibility beyond social networking. By storing pastes as ATproto records, Plonk creates a persistent, us-owned archive of code snippets and text that lives alongside your social content. And, with both Tangled and Plonk, we do indeed have the makings for a legit GitHub/GitLab replacment in the works.
This approach also means your pastes inherit the same data portability benefits as other ATproto content — they’re part of your digital identity that you can take with you across compatible services.
As the ATproto ecosystem continues to grow, we’ll likely see more creative applications like Plonk that extend the protocol’s utility beyond its initial social networking focus. The decentralized nature of ATproto makes it an excellent foundation for building us-owned content services of all kinds.
Notetaking Just Comes Nash-ually For Some
Nash (GH) is a web-based note-taking application that runs entirely in your browser. It is both simple and highly portabile—create, edit, and save notes as HTML files without any server dependencies.
The interface is refreshingly straightforward: a title field and content area where the magic happens. Despite its minimalist appearance, Nash offers a surprisingly robust set of formatting tools.
Text formatting options range from size adjustments (XL, L, M, S) to the classics—bold, italic, and underline. You can easily insert links and upload images, plus add some visual flair with text coloring and highlighting. When you’ve finished crafting your note, Nash gives you several saving options. Save locally as an HTML file, share it directly (if your browser supports the share API), or create read-only versions for distribution.
Technically speaking, Nash uses contentEditable divs for both the title and editor components. The developmer has implemented custom JavaScript functions that handle everything from text formatting through DOM manipulation to selection and range handling for applying styles.
The editor supports block-level formatting like headings and paragraphs, image insertion via the FileReader API, and color application using CSS variables for consistent theming. Perhaps most impressively, its export functionality packages everything into a self-contained HTML document.
Nash includes several thoughtful quality-of-life features. Dark mode support via CSS media queries means your eyes won’t burn during late-night writing sessions. The application automatically normalizes content structure, confirms before opening links (no accidental navigation!), and warns you about unsaved changes.
Since all processing happens client-side with zero server requirements, Nash is a truly portable solution for note-taking. Take it anywhere, use it anytime, without worrying about connectivity or account management.
The Arc Of The Universe Bends Towards Ad Blocking
I’m on the bleeding edge releases of Arc and they recently added advert/tracker/cookie-consent blocking to this spiffy Chromium-based browser alternative.
Google’s Manifest V3 update severely limits extension capabilities, particularly for ad blocking. Arc’s integrated ad blocker bypasses these restrictions, aiming for a “cleaner internet” with fewer ads and distractions. It appears to just be using the same lists that uBlock Origin uses:
It does ask you to use only one blocker, so I’m giving this a go for a while. It frustratingly does not yet support an “allow” list, and does not have a quick way to temporarily disable the built-in blocker.
This move aligns with Arc’s clean interface philosophy while directly challenging Google and Microsoft’s ad revenue models. By addressing the limitations of Manifest V3, Arc targets privacy-conscious folks dissatisfied with Chrome’s direction. I should further reiterate that I use a total of ZERO of Arc’s AI features, have Kagi as my browser search ending, and run Arc every two weeks from my PCAP logging VLAN to make sure it’s not being naughty and shunting my browser sessions to their AI servers. So, all of said privacy claims have that in mind.
Unfortunately — for now — both Arc and Vivaldi faile the “protect me from sociopaths” test quite miserably, as Chromium Canary (which they both use as a baseline) nuked our ability to turn off all the new Google spying settings. I was afraid Google might have co-mingled the evil advert code too deeply into the browser core ops, and I suspect that is the case, here.
FIN
Remember, you can follow and interact with the full text of The Daily Drop’s free posts on:
- 🐘 Mastodon via
@[url=https://dailydrop.hrbrmstr.dev/@dailydrop.hrbrmstr.dev]dailydrop.hrbrmstr.dev@dailydrop.hrbrmstr.dev[/url] - 🦋 Bluesky via
https://bsky.app/profile/dailydrop.hrbrmstr.dev.web.brid.gy
Also, refer to:
to see how to access a regularly updated database of all the Drops with extracted links, and full-text search capability. ☮️
GitHub - keepworking/nash: Note as HTML
Note as HTML. Contribute to keepworking/nash development by creating an account on GitHub.GitHub
Bonus Drop #78 (2025-03-09): Knot Your Parents’ Social-Enabled Git Collaboration Platform
Oh What A Tangled Code We WeaveJust one topic today since it took a bit more time to dissect the topic than I anticipated.
Hit me up if you have any issues getting your own “knot” untangled.
Oh What A Tangled Code We Weave
Tangled (Blog | Bsky) is a new platform for Git-based collaboration that blends the benefits of decentralized systems with human-friendly social features. It’s built on top of the AT Protocol (i.e., the thing that Bsky invented), seeking to give developers ownership of our code while fostering open-source community governance and a more social coding experience, free from billionaire and empire controls.If U.S. and global Drop readers haven’t yet received the memo that you should be avoiding U.S.-hosted services and billionaire/global-mega-corp controlled platforms, consider said memo now delivered.
Instead of choosing between a fully federated model like Forgejo (which uses ActivityPub) or a purely peer-to-peer approach like Radicle, Tangled provides a decentralized social networking framework with a central identity system. If you have a looksie into the AT Protocol documentation, you’ll find key concepts like:
- Repositories: These are self-authenticating storage units for a our content.
- Lexicon: This is a schema language used to define the structure of data within the AT Protocol.
- App Views: The documentation refers to these as consolidated views into the network. In Tangled’s case, the app view at tangled.sh provides a unified interface for accessing and contributing to repositories hosted across different “knots.”
To put that last bullet a different way, Tangled “knots” are lightweight servers that host Git repositories. These knots can be single-tenant (think self-hosting on a Raspberry Pi) or multi-tenant (for larger community servers). Tangled provides (free) managed knots as a default, lowering the barrier to entry.
The project is still in its early stages, with the Tangled team actively developing core features while “dogfooding” the platform themselves. Their design decisions are guided by three principles: data ownership, low barrier to entry, and a strong interactive experience. The goal is to make collaboration feel natural and intuitive, even within a decentralized environment.
For readers that just want to try it out head on over to
tangled.shand you can see the “firehose”:
To do much beyond being a voyeur and/or cloning repos over HTTPS, you’ll need to authenticate to the network via your Bluesky handle and a generated app password (I’m confident oauth is coming at some point for Tangled). Once you login, tap your handle (upper-right corner) and add some SSH public keys (via “settings”).I made a repo for this Bonus Drop:
to test it out and give y’all something to poke at.The point of Tangled is to foster decentralized social coding, which means if you’re going to be serious about using this service, you should create your own “knot” (a cute word for a Tangled instance that will broker access to the repos via the Tangled AppView and git SSH/HTTPS ops).
The core project Readme has all you need to walkthrough the creation of an instance. There are three Golang binaries (well, four, really, but you’re likely going to rely on Tangled for the AppView) in the mix.
keyfetchis a program designed to run as an SSHAuthorizedKeysCommand. It fetches SSH public keys from an internal API endpoint and formats them for use with SSH authentication. When a user attempts to connect via SSH, keyfetch:
- retrieves a list of authorized keys from a specified internal API endpoint
- formats these keys with specific command restrictions
- outputs the formatted keys to be used by the SSH server for authentication
This lets the Tangled platform dynamically manage SSH access to Git repositories based on user credentials stored in its system. If you did load your PUBLIC keys into Tangled, you can run
keyfetchmanually (after you successfully bootstrap your knot) to see the output.
knotserver/knotis a core component of the architecture that manages the “knots” — those lightweight, headless servers that host Git repositories. Theknotserver:
- sets up and manages the database for storing repository information
- implements role-based access control (RBAC) for repository permissions
- integrates with Jetstream for event handling and communication
- runs both a main server and an internal server on different ports
The
knotserveressentially provides the backend infrastructure for hosting and managing repositories within a knot, handling authentication, authorization, and API endpoints.
repoguardacts as a security layer between SSH connections and Git operations. It:
- validates incoming Git commands from users connecting via SSH
- resolves user identities (handles or DIDs) to their proper DID format
- verifies that users have appropriate permissions for the requested operations
- executes the Git commands in a controlled environment
- logs all access attempts and operations for security purposes
repoguardensures that only authorized users can perform specific Git operations on repositories, providing security and access control at the Git command level.Together, these three components form part of the infrastructure that enables Tangled’s decentralized Git collaboration platform, with keyfetch handling SSH key management, knotserver providing the repository hosting backend, and repoguard securing Git operations.
I rean it on one of my public internet-facing services, but since the recommended config is to use a reverse proxy to the localhost port
5555service (which I used Caddy for), there is nothing stopping you from running this instance on your local network and reverse proxying to a Tailscale interface.NOTE: if you use their recommendedsystemdsetup, you’ll need to modifyknotserver.serviceand changeExecStart=/usr/local/bin/knotservertoExecStart=/usr/local/bin/knotand make sure to restartsshd.
If you hit upknot.hrbrmstr.appyou’ll get:This is a knot server. More info at tangled.sh
instead of that minimalist web interface you saw on
tangled.sh.The reason for this is that Tangled provides the AppView to the federated AT protocol brokered knot instances (much in the same way Bluesky is the AppView for all Bluesky-compatible PDS instances and WhiteWind is the blog hub AppView for all of the WhiteWind compatible PDS isntances).
Sice this is all happening on the AT protocol, we can even explore things from the protocol-perspective.
If you start at my (or your
did):https://pdsls.dev/at://did:plc:hgyzg2hn6zxpqokmp5c2xrdo, you can see all of the available collections:app.bsky.actor.profileapp.bsky.feed.likeapp.bsky.feed.postapp.bsky.feed.postgateapp.bsky.feed.repostapp.bsky.feed.threadgateapp.bsky.graph.blockapp.bsky.graph.followapp.bsky.graph.listapp.bsky.graph.listblockapp.bsky.graph.listitemblue.zio.atfile.uploadchat.bsky.actor.declarationcom.whtwnd.blog.entrysh.tangled.feed.starsh.tangled.graph.followsh.tangled.publicKeysh.tangled.reposh.tangled.repo.issuesh.tangled.repo.issue.comment
Well, look at all the ones on the
sh.tangled.*PDS!If we follow one
repopath to the end:https://pdsls.dev/at://did:plc:hgyzg2hn6zxpqokmp5c2xrdo/sh.tangled.repo/3ljx2j3twex22, we can get the metadata:{ "knot": "knot.hrbrmstr.app", "name": "my-first-self-hosted-knot-repo", "$type": "sh.tangled.repo", "owner": "did:plc:hgyzg2hn6zxpqokmp5c2xrdo", "addedAt": "2025-03-09T12:37:24Z"}
This also means there’s nothing stopping anyone from building off of this new ecosystem.
I’m not sure why I find Tangled easier to grok (thanks to a certain individual and service I think I need to find a new word to use) than Radicle, but it seems to fit my mental model better.
You can check out both the example repo for this post, or the uncreatively-named one on my knot.
If you join Tangled drop me a note so I can follow you there, and send me your handle if you’d like to see how it works when you hit up my instance.
FIN
Remember, you can follow and interact with the full text of The Daily Drop’s free posts on:
- 🐘 Mastodon via
@[url=https://dailydrop.hrbrmstr.dev/@dailydrop.hrbrmstr.dev]dailydrop.hrbrmstr.dev@dailydrop.hrbrmstr.dev[/url]- 🦋 Bluesky via
https://bsky.app/profile/dailydrop.hrbrmstr.dev.web.brid.gyAlso, refer to:
to see how to access a regularly updated database of all the Drops with extracted links, and full-text search capability. ☮️
