https://github.com/AnalogJ/lexicon -- Manipulate DNS records on various DNS providers in a standardized way.

12# Create a TXT entry in domain.net zone hosted by CloudFlare
lexicon cloudflare create domain.net TXT --name foo --content bar

Ah, Doom based.

Yeah :/ Still searching for a good way to reproducably emacs

https://omar.website/tabfs/

https://github.com/osnr/TabFS

This would work.

If yall arent familiar.

https://omar.website/posts/notes-from-dynamicland-geokit/

https://dynamicland.org/

https://depp.brause.cc/nov.el/ -- nov.el provides a major mode for reading EPUB documents.

Features:

1234567891011Basic navigation (jump to TOC, previous/next chapter)
Remembering and restoring the last read position
Jump to next chapter when scrolling beyond end
Storing and following Org links to EPUB files
Renders EPUB2 (.ncx) and EPUB3 (<nav>) TOCs
Hyperlinks to internal and external targets
Supports textual and image documents
Info-style history navigation
View source of document files
Metadata display
Image rescaling

checkpoint it to a hard drive as a collection of files. You can then use the files to restore and run the application from the point it was frozen at.

Imagine freezing a whole container and saving it to physical paper

https://github.com/aler9/rtsp-simple-server -- ready-to-use and zero-dependency RTSP / RTMP / HLS server and proxy that allows to read, publish and proxy video and audio streams

• Publish live streams to the server
• Read live streams from the server
• Act as a proxy and serve streams from other servers or cameras, always or on-demand
• Each stream can have multiple video and audio tracks, encoded with any codec, including H264, H265, VP8, VP9, MPEG2, MP3, AAC, Opus, PCM, JPEG
• Streams are automatically converted from a protocol to another. For instance, it's possible to publish a stream with RTSP and read it with HLS
• Serve multiple streams at once in separate paths
• Authenticate users; use internal or external authentication
• Query and control the server through an HTTP API
• Read Prometheus-compatible metrics
• Redirect readers to other RTSP servers (load balancing)
• Run external commands when clients connect, disconnect, read or publish streams
• Reload the configuration without disconnecting existing clients (hot reloading)
• Compatible with Linux, Windows and macOS, does not require any dependency or interpreter, it's a single executable

https://gitlab.com/nbdkit/nbdkit -- nbdkit is an NBD server. NBD — Network Block Device — is a protocol
for accessing Block Devices (hard disks and disk-like things) over a
Network.

The key features of nbdkit are:

• Multithreaded NBD server written in C with good performance.

• Minimal dependencies for the basic server.

• Liberal license (BSD) allows nbdkit to be linked to proprietary
  libraries or included in proprietary code.

• Well-documented, simple plugin API with a stable ABI guarantee.
  Lets you export “unconventional” block devices easily.

• You can write plugins in C/C++, Go, Lua, Perl, Python, OCaml, Ruby,
  Rust, shell script or Tcl.

• Filters can be stacked in front of plugins to transform the output.

http://www.pogo.org.uk/~mark/trx/ -- trx is a simple toolset for broadcasting live audio from Linux. It sends and receives encoded audio over IP networks, via a soundcard or audio interface.

It can be used for point-to-point audio links or multicast, eg. private transmitter links for a radio station or other live audio distribution. In contrast to traditional streaming, high quality wideband audio (such as music) can be sent with low-latency, typically as low as a few milliseconds, and incredibly fast recovery from dropouts.

Unlike TCP streaming such as Icecast, trx uses RTP/UDP with handling of dropped packets and network congestion that is more appropriate to live or realtime audio. Much of this comes courtesy of the brilliant Opus audio codec. The result is an incredibly graceful handling of network loss or dropouts.

It is intended for use over closed or private IP networks. It can be used over the public internet, but you are warned that it has no built-in security or authentication of the received audio. If you do not already have a private network you may wish to use an appropriate tunnel or IPsec.

This list of examples is not comprehensive:

1234567891011121314tx -h 192.168.0.32         # send audio from default soundcard to the given host
rx                         # receive audio and play it

tx -h 192.168.0.32 -b 32   # send audio as above, with a lower 32kbps data rate
tx -h 192.168.0.32 -m 128  # larger buffer for a non-professional soundcard

tx -h 192.168.0.32 -f 480  # smaller frames for decreased latency
rx -j 4                    # smaller jitter buffer for decreased latency

tx -h 239.0.0.1            # send audio over multicast
rx -h 239.0.0.1            # recieve audio from the above

tx -?                      # full list of transmitter parameters
rx -?                      # full list of receiver parameters

This has great docs.

Reference implementation https://www.liquidsoap.info/doc-2.0.4/complete_case.html

^ We will develop here a more complex example, according to the following specifications:
play different playlists during the day;
play user requests – done via the telnet server;
insert about 1 jingle every 5 songs;
add one special jingle at the beginning of every hour, mixed on top of the normal stream;
relay live shows as soon as one is available;
and set up several outputs.

https://github.com/markqvist/lxmf -- Lightweight Extensible Message Format

LXMF is a simple and flexible messaging format and delivery protocol that allows a wide variety of implementations, while using as little bandwidth as possible. It is built on top of Reticulum and offers zero-conf message routing, end-to-end encryption and Forward Secrecy by default.
Structure

LXMF messages are stored in a simple and efficient format, that's easy to parse and write.
The format follows this general structure:

12345678Destination
Source
Ed25519 Signature
Payload
    Timestamp
    Content
    Title
    Fields

LXM Propagation Nodes offer a way to store and forward messages to users or endpoints that are not directly reachable at the time of message emission. Propagation Nodes can also provide infrastructure for distributed bulletin, news or discussion boards.

When Propagation Nodes exist on a Reticulum network, they will by default peer with each other and synchronise messages, automatically creating an encrypted, distributed message store. Users and other endpoints can retrieve messages destined for them from any available Propagation Nodes on the network.

https://github.com/symeapp/syme -- A zero-knowledge key architecture and encrypted messaging platform

Our security objectives are to:

12345provide a means for users and servers to establish mutual authentication without communicating password-equivalent data;

provide a means for users to securely establish and maintain lists of trusted keys, with mechanisms for adding and revoking keys;

and provide a system for multiparty communication of encrypted data that ensures integrity and non-repudiation.

There is currently renewed interest in encrypted communication protocols that are adapted to live communication tools such as instant messaging [1,2]. However, these protocols are not well suited for persistent communication systems, such as social networks, where users are not necessarily online at the same time. We propose a zero-knowledge key infrastructure that uses end-to-end encryption to enable persistent multiparty communication and secure key exchanges on minimally trusted servers and relays.

https://github.com/audapolis/audapolis -- An editor for spoken-word media with transcription.

audapolis aims to make the workflow for spoken-word-heavy media editing easier, faster and more accessible.

12345It gives you a wordprocessor-like experience for media editing.
It can automatically transcribe your audio to text.
It can be used for Video, Audio and mixed editing - Do radio shows, podcasts, audiobooks, interview clips or anything you like.
It is free
It keeps the data in your hands - no cloud whatsoever.

http://antsp2p.sourceforge.net/ -- (ABANDONED) ANts P2P realizes a third generation P2P net. It protects your privacy while you are connected and it makes you not trackable, hiding your identity (ip) and crypting everything you are sending/receiving from others.
Features

12345678910111213141516Open Source Java implementation (GNU-GPL license)
Multiple sources download
Swarming from partial files
Automatic resume and sources research over the net
Search by hash, string and structured query
Completely Object-Oriented routing protocol
Point to Point secured comunication: DH(512)-AES(128)
EndPoint to EndPoint secured comunication: DH(512)-AES(128)
Serverless GWebCache-based peer dicovery procedure
IRC based peer discovery system
IRC embeded chat system
Full text search of indexed documents (pdf, html, txt, doc etc)
Distributed/Decentralized Search engine
HTTP tunneling
ANts allow P2P communications through any kind of HTTP Proxy
ANts allow P2P communications through any kind of NAT or traffic filtering system 

https://github.com/kelseyhightower/confd -- Manage local application configuration files using templates and data from etcd or consul

http://www.confd.io/

A lightweight configuration management tool focused on:

• Sync configuration files by polling etcd or consul and processing template resources.
• Reloading applications to pick up new config file changes

https://github.com/hartsick/ruBB -- RuBB, a very minimal Rails-based forum for friends

Currently a work-in-progress that aims to be like

Deeply influenced by

Guiding principles

These are a work-in-progress, but capture some of what has been guiding me:

123456Enable collective decisionmaking
Keep things small and intentional (do not assume or encourage scale, build tools that enable and rely on trust)
As much as possible, keep one view of the forum so that all information is shared (eg don't allow custimization that would significantly change someone's experience)
Do not privilege those with technical systems access (there is a lot baked into this, but essentially technical maintainers should not necessarily be the moderators)
The forum does not make asks of your attention, but tries to give you tools manage your experience
Keep the architecture conventional and maintenance as simple as possible. It shouldn't be a pain to maintain

Features

The forum is constantly changing since it's under active development, but here are some features as of Jan 8, 2022, along with some current screenshots (it is easy to change the color scheme of the site and I do it frequently—-this is currently based off Zenburn).

Feature list:

1234567Account creation via Rake task
Basic account management (setting profile, resetting password -- right now users can't change their email or username)
Each person can invite one person each month
Users can star threads to keep track of them, and see all their starred threads
Users can pin threads so that they are easily found by entire forum (intended for onboarding / community things)
Users can see when there are unread messages in a thread
Users can mention others, and be visually notified when they have been mentioned in a thread

RethinkDNS + Firewall for Android
An OpenSnitch-inspired firewall and network monitor + a pi-hole-inspired DNS over HTTPS client with blocklists.

https://github.com/celzero/rethink-app

I'm not endorsing or using this, but wanted to share.

There was some kind of beef between them and the developers of Blokada over who had the shittier business model. Not sure how that ended up, or if it matters.

https://matrix.org/blog/2019/03/12/breaking-the-100-bps-barrier-with-matrix-meshsim-coap-proxy

https://www.youtube.com/watch?v=DZBvy4abB1o

We selected a very overkill PMIC, the TI BQ25890, for this tiny little device. It has a very important feature: power on without battery. I always wondered why most phones can't power on with only a power cable. Anyway, this feature is supported in our case. This also enables you to switch batteries without powering off with power cable connected. Moreover, it provides the power switch functionality, and a steady 5V 1A power supply for USB OTG.

This is pretty wild: https://github.com/alievk/avatarify-desktop

I love it. One of my goals for this project is to have A/V shims that add some privacy to audio/video via transformation (deepfake/voice changer) and adversarial overlays that directly attack ML analysis.

Video transformation seems to be coming along well, but there's not a ton of out of the box adversarial stuff yet. Adversarial examples are a pretty well known weakness that seems inherent to modern ai/ml approaches but most of the software is academic right now. I'm excited to see where this goes, maybe we can win back some semblance of privacy here.

https://github.com/yuliskov/SmartTubeNext -- SmartTubeNext is an advanced YouTube app for Android TVs and TV boxes, free & open source.

• Features: no ads | SponsorBlock | adjustable playback speed | 4k and higher | 60fps | HDR | does not require Google Services | helpful international community

• Disadvantages: no live chat | no comments stability, voice search and casting support might be worse than in the official YouTube, depending on your device

Tested on fire stick

Things I like about it: better UI for AndroidTV than NewPipe. Seems usually to do a better job of picking the best quality stream. Integrates SponsorBlock (there is a NewPipe fork with SponsorBlock, but I suspect it is out of date).

Things I don't like about it: can't save playlists and subscriptions unless you log into a YouTube account, whereas NewPipe stores playlists and subscriptions locally.

https://github.com/vexorian/dizquetv -- Create live TV channels from your own media. Access the streams using the simulated HDHomerun tuner or the generated M3U URl.

Configure your channels, programs, commercials and settings using the dizqueTV web UI.

Access your channels by adding the spoofed dizqueTV HDHomerun tuner to Plex, Jellyfin or emby or utilize the M3U Url with any 3rd party IPTV player app.

Features

• A wide variety of options for the clients where you can play the TV channels, since it both spoofs a HDHR tuner and a IPTV channel list.
• Ease of setup for xteve and Plex playback by mocking a HDHR server.
• Configure your channels once, and play them just the same in any of the other devices.
• Customize your channels and what they play. Make them display their logo while they play. Play filler content ("commercials", music videos, prerolls, channel branding videos) at specific times to pad time.
• Docker image and prepackage binaries for Windows, Linux and Mac.
• Supports nvidia for hardware encoding, including in docker.
• Select media (desired programs and commercials) across multiple Plex servers
• Includes a WEB TV Guide where you can even play channels in your desktop by using your local media player.
• Subtitle support.
• Auto deinterlace any Plex media not marked "scanType": "progressive"
• Can be configured to completely force Direct play, if you are ready for the caveats.

https://github.com/civboot/civboot -- Civboot: a civilizational bootstrapper

How large would a warehouse have to be in order to both:

• Build simple computers in a semi-autonomous way from scratch using only tools and knowledge within the warehouse.
• Build another such warehouse and make improvements to it.

If such a warehouse existed, it would be a Civboot. Civboot aims to simplify technology by simplifying technology's requirements. Fundamentally Civboot is an educational tool: it can provide a working understanding of the tools and processes that underpin our technology. Putting the question another way, if there were a high-school & college curriculum with the sole goal of accomplishing "project based learning" of having the entire class (400+ students) understand and reconstruct a Civboot using only the tools within the Civboot; how many people would that be, how large would the warehouse be and how many instructors would be required?

This is the fundamental question of Civboot, a project which aims to reduce the tools and knowledge necessary to bootstrap modern civilization as much as possible. It is important to point out early that a Civboot does not contain everything required to build or support civilization such as food, clothing or a bed; in the same way as a bootstrapper for an operating system does not contain all the bells and whistles of the operating system itself. A Civboot only contains the tools and knowledge necessary to build computers and itself.

In terms of supporting a community with things like food, clothing and shelter, a Civboot has one additional goal: be able to provide these things within three degrees. For instance, a Civboot cannot construct a tractor directly, but you can use tooling within a Civboot to build a factory (the 1st degree), then you can use the factory to build gears and other tractor components and assemble a tractor (the 2nd degree).

Another point: a Civboot only contains tutorials to provide a working knowledge of how to reconstruct and improve the Civboot. Deeper understanding of things like transistors, hardware architecture, software architecture, chemistry, mechanical engineering, etc can take potentially a lifetime of learning. It is hoped that Civboot can be a foundation for that learning, but Civboot itself aims to provide only a working understanding.

https://github.com/kongmunist/asciiZOOM -- This alternative to Zoom offers a secure, end-to-end encrypted way to video chat from the safety of your terminal.

Lol

http://arclanguage.org/ This site is about Arc, a new dialect of Lisp.

Arc is designed for exploratory programming: the kind where you decide what to write by writing it. A good medium for exploratory programming is one that makes programs brief and malleable, so that's what we've aimed for. This is a medium for sketching software.

 It's not a coincidence that we wrote a language for exploratory programming rather than the sort where an army of programmers builds a big, bureaucratic piece of software for a big, bureaucratic organization. Exploratory programming is the fun end of programming, and we hope that will be the guiding principle of the Arc community

trying it out, yeah. home manager "integration" looks like this:

1xdg.configFile."aerc/accounts.conf".source = config.lib.file.mkOutOfStoreSymlink ./secrets/aerc/accounts.conf;

https://github.com/netenglabs/suzieq -- Healthier Networks Through Network Observability

Would you like to be able to easily answer trivial questions such as how many unique prefixes are there in your routing table, or how many MAC addresses are there in the MAC tables across the network? How about more difficult questions, such as what changes did your routing table see between 10 pm and midnight last night, or which of your nodes have been up the longest, or which BGP sessions have had the most routing updates? How about being able to answer if your OSPF (or BGP) sessions are working correctly, or is all well with your EVPN? How about a quick way to determine the amount of ECMP at every hop between two endpoints? Do you wish you could easily validate the configuration you deployed across your network?

Do you login to every network node you have to figure out answers to a questions like these? Do you then struggle to piece the information together into a consistent whole across the various formats provided by various vendors? Do you wish you had an open source, multi-vendor tool that could help you answer questions like these and more?

If you answered yes to one or more of these questions, then Suzieq is a tool that we think will be interesting to you. Suzieq helps you find things in your network.

My main issue was that the most straightforward usecase presents mainly a tempting way of getting in trouble at work.

Did someone recommend an Android RSS reader a while ago? I've been trying a few, and none are fully satisfactory.

https://github.com/felipeleivav/yboard -- Yboard is a multiplayer desktop-like workspace based on Yjs

Online demo

I'm interested in the idea of CRDTs. They do seem like a way forward, if not the way. I need to look at some non-JS implementations, and play around with different types.

Arc is unfinished. It's missing things you'd need to solve some types of problems. But it works well for 

basic web apps.

https://news.itsfoss.com/gnome-web-extensions-dev/

https://mntre.com/media/reform_md/2022-06-20-introducing-mnt-pocket-reform.html – 7" MNT Reform.

I really like the "bento box" form factor.

we can abuse a bit the system and create a sepparate trigger program that notifies the capture program using a pin, that's why GPIO0 and GPIO1 are shorted.

they’re using GPIOs as cross-core RPC. i have to admire that hack, because it might actually be the only way to pull that off.

https://gitlab.com/sequoia-pgp/sequoia

Sequoia's a stateless PGP implementation. unlike gpg, there's no ~/.gnupg key store: you manage private and pubkeys however you want, and pass them into sequoia externally.

e.g.

1sq verify --signer-cert path/to/senders/pubkey.pub path/to/signed/file

Y'all gotta jump on the nixos train fr fr

https://github.com/telent/nixwrt

https://github.com/cleverca22/not-os

https://github.com/NsCDE/NsCDE NsCDE is a retro but powerful UNIX desktop environment which resembles CDE look (and partially feel) but with a more powerful and flexible framework beneath-the-surface, more suited for 21st century unix-like and Linux systems and user requirements than original CDE.

NsCDE can be considered as a heavyweight FVWM theme on steroids, but combined with a couple other free software components and custom FVWM applications and a lot of configuration, NsCDE can be considered a lightweight hybrid desktop environment.

In other words, NsCDE is a heavy FVWM (ab)user. It consists of a set of FVWM applications and configurations, enriched with Python and Shell background drivers, couple of the additional free software tools and applications. FVWM3 is also supported.

nightcafe has entered the chat

https://github.com/zhoreeq/meshname

https://github.com/popura-network/PopuraDNS

https://simfish.dev/projects/gix/ -- Gix: Literate Programming with Emacs org-mode & GNU/Guix

Gix is a collection of utility scripts that leverage GNU/Guix software management features to simplify literate programming with Emacs org-mode.

https://github.com/JsBergbau/BindToInterface -- securely bind a programm to a specific network interface or network adapter

Bind To Interface is a useful program for unix/linux if you have multiple network interfaces or adapters and want your program use strictly only one or none. You don't have to bother with routing tables, network namespaces or iptables and marking packets.

BindToInterface is very flexible. You can set exceptions to which IPs no binding should be made. This is especially useful if your program still needs to communicate with

https://sr.ht/~ilmu/tala.saman/ -- This is a preliminary introduction to a project that is very hard to explain due to how fundamental it is. We are interested in building society on a stable foundation and with computers becoming an increasingly fundamental part of the coordination of human behaviour we worry about the incentives being created.

The datalisp project builds on some very simple ideas:

• the duality of code and data (universal turing machine proves this)
• canonical representatives for equality comparisons (think torrent seeding)
• free software as a foundation for a democratic society
• the peer to peer model as a more accurate description of reality - therefore; decentralized coordination of society
• persuasion as means to updating software (coercion / centralization is systemic risk)
• trust as a channel for effective communication (information you don't trust is noise)
• probabilistic assessment of trust as the foundation of economics
• sufficiency of economics to coordinate name system
• sufficiency of name system to coordinate society
• conflict resolution as a "join" in name system lattice (actually is the meet - trade)
• reified conflicts as a form of conflict resolution (the join - market)
• currency exchange rates as measurement of relative legitimacy

the basic plan is:

• having a FOSS, bootstrappable and reproducible system that can serve as "the" peer (symmetry of p2p)
• having a theoretically sound data interchange format to build a namesystem on (canonical S-expressions)
• having all tools required to evolve the peer within this namesystem thing and then build economics around this stuff; it may seem like an impossible problem but I think if you arrange everything correctly then it will almost happen by itself (jsut in order to manage complexity: https://youtu.be/Lgs9QUtWc3M)

Just commenting since that is "my" project... I was on nixos before but I moved to guix because they take the whole bootstrapping thing and FOSS thing a bit more seriously. Also I think guile is an improvement over json-with-lambdas and that datalisp is an improvement over that stuff.. but let's see what happens.

the basic plan is:

• having a FOSS, bootstrappable and reproducible system that can serve as "the" peer (symmetry of p2p)
• having a theoretically sound data interchange format to build a namesystem on (canonical S-expressions)
• having all tools required to evolve the peer within this namesystem thing and then build economics around this stuff; it may seem like an impossible problem but I think if you arrange everything correctly then it will almost happen by itself (jsut in order to manage complexity: https://youtu.be/Lgs9QUtWc3M)

This is what I'm trying to build here, too.

it may seem like an impossible problem but I think if you arrange everything correctly then it will almost happen by itself

YES!! I've been seeing things fall together even as early stage as my experiments are, and I've been fighting nixlang the whole time.

https://hackaday.com/2022/08/10/a-linear-actuator-entirely-in-one-pcb/

https://benwang.dev/2022/08/09/PCB-Linear-Actuator.html

Even has (unimplemented) quadtrature absolute encoder.

100mm moves take under 200ms
It takes approximately 60ms to achieve 2100mm/s, for an acceleration of around 35m/s^2, and it takes approximately 40ms to decelerate back to 100mm/s, for deceleration of around 50m/s^2.

Better performance can likely be achieved with higher currents, but I’m limited by the quite low OCP of my power supply (which is a macbook charger…