Mentions

Conversations linking to GitHub, newest first. Times are UTC.

Mentions by source

X

7,160
Nov 17, 15:00Nov 18, 15:00

Bluesky

2,284
Nov 17, 18:00Nov 18, 18:00
Nov 17, 17:00Nov 18, 17:00
Nov 17, 17:00Nov 18, 17:00
Nov 17, 18:00Nov 18, 18:00
Nov 17, 18:00Nov 18, 18:00
Nov 17, 17:00Nov 18, 17:00
Nov 17, 16:00Nov 18, 16:00
Oct 14, 21:00Oct 15, 21:00

Delayed · data through Oct 15, 21:00 UTC

DEV

832
Nov 17, 18:00Nov 18, 18:00
Nov 17, 18:00Nov 18, 18:00
Nov 16, 11:00Nov 17, 11:00

Delayed · data through Nov 17, 11:00 UTC

Nov 17, 18:00Nov 18, 18:00
Oct 28, 01:00Oct 29, 01:00

Delayed · data through Oct 29, 01:00 UTC

Nov 8, 11:00Nov 9, 11:00

Delayed · data through Nov 9, 11:00 UTC

Nov 17, 18:00Nov 18, 18:00

Latest posts

  1. Redditu/wolftech029 · r/GalaxyZFold · 22 points · 11 comments

    Folio Update v. 0.6.9: A Defined Launcher Hey everyone! Folio is really getting to a good spot as it becomes a more defined launcher of its own. Lately, a lot of work has happened in the background to improve support and performance, and I hope you like where it’s going. For those coming over from iOS, please consider giving it a try! What’s changed in 0.6.9? - A big focus on speed and performance, with cleaner animations and a lot of bug fixes. - More polish for the Dynamic Island. - New wallpapers, with credit to the photographers. I figured some more options would be nice. Feel free to share your own setups and wallpapers too! - Improvements to Control Center, notifications, folders, and Home customization. Some of these changes are small, but together they’ve helped things feel more consistent. A little about development One of the biggest challenges has been working around what Android’s APIs make available, finding other ways to get features working while avoiding the need to root your phone wherever possible. I’m also getting started on bringing Folio to Google Play. That version may have a more limited feature set, since distributing the APK directly gives me more freedom with what Folio can do. I’m still one person working on this, so that’s one of my biggest limitations, but I’m beyond proud of what it’s becoming. What do you think is missing? Do you like the UI? Is there anything that feels awkward or something you wish it could do? I’m always interested in where Folio can go as its own launcher, beyond its iOS inspiration. There’s also a bunch of new stuff coming in 0.7.0! Download Folio · Full changelog Lastly, thanks for following along, emailing, reaching out, and supporting this. It’s grown into something really cool that I’m beyond proud of. Thanks for helping make my small little app a reality!

  2. High availability on European cloud providers: I simulated losing a zone on four clouds Why this test While developing Flui, an open-source platform for deploying and managing the application lifecycle on one’s own servers or with European providers, I asked myself how to approach high availability. Specifically, the type of resilience I’m trying to test is the total failure of a data center. The textbook answer is simple: three availability zones, a Kubernetes cluster deployed across them, and a replicated database. However, I wanted to know what actually happens when a zone goes down, and I wanted to measure this across European providers: these are features taken for granted on hyperscalers which hide real complexity. There are various reasons for adopting these providers: the push from regulations such as DORA (and the CADA, currently under discussion), concerns about data sovereignty, or simply economic considerations. Here I focus on the technical side. So I set up the same K3s cluster (a lightweight Kubernetes distribution) on OVHcloud and Scaleway in Milan, on Hetzner in three cities, and on AWS, also in Milan. Same scripts, same tests, three repetitions for each failure. A note on AWS. It’s my baseline: I’ve worked with it for years and know what it delivers. This isn’t a direct benchmark, because the conditions are different: non-identical machines, different vCPU types, different disks. But this is what the market offers, and the comparison must be made, cost included. Every service has its own characteristics, and everyone chooses what they need. I’ll line up the numbers side by side and explain what each difference is due to. I’m treating Hetzner separately because it doesn’t have availability zones but rather data centers located in different cities, and a direct comparison wouldn’t have made sense in this case. This is the first part, covering the cluster. Databases, volumes, and other aspects worth discussing will follow. In short - 4 of 4 providers on which the cluster survives the simulated loss of a zone, three runs each - 6-10 s writes blocked on Kubernetes when the zone of the node coordinating writes is lost. The same on every provider - about 1 ms between the Milan zones on AWS, OVH and Scaleway - 3 vs 24-36 ms on Hetzner: between the two German locations, and from Germany to Helsinki. What I built The cluster uses K3s: it’s a single executable that already contains everything needed, so it’s well-suited for small clusters like this one. Three machines, one per zone, each with a node that acts as both a control plane and a worker. No managed services: no EKS, no managed databases. K3s is installed with the default settings; the only change I made is to set up three copies of the internal DNS, and I’ll explain why later. The scripts are public, and each cycle costs just a few euros. Kubernetes stores the entire cluster state in a small database called etcd: which apps are running, where, and with what settings. Here, one copy runs per zone, and the three copies coordinate using a mechanism called Raft. In short, it works like this: - a single copy acts as the leader: it receives writes and passes them on to the other two; - a write is confirmed when it has a majority, that is, two out of three copies. This is why three copies can withstand the loss of one, but not two; - the leader continuously sends a heartbeat signal to the other copies. If they stop receiving it for a few seconds, they elect a new leader, and here too a majority of votes is required; - until a new leader is elected, the cluster’s state cannot be changed. Apps that are already running continue to respond. I chose the 2 vCPU, 4 GB machine that every provider sells in all three zones in Milan: sufficient for our experiments at an affordable cost. | | AWS | OVHcloud | Scaleway | | --- | --- | --- | --- | | Where | Milan, 3 zones | Milan, 3 zones | Milan, 3 zones | | Machine | c7i.large | c3-4 | BASIC3-X2C-4G | | CPU | Intel Xeon 8488C | AMD EPYC Milan | AMD EPYC 9555P | | vCPU / RAM | 2 / 4 GB | 2 / 4 GB | 2 / 4 GB | | vCPU type | 1 core with 2 threads, not shared | guaranteed resources, according to OVH | shared | | Measured CPU steal | below 0.2% | below 0.1% | from about 1% to 13%, depending on the node | | Disk | network gp3, 5,000 IOPS, 2,000 of them paid extra | local NVMe, not replicated | network, 5,000 IOPS, replicated in 3 copies | CPU. On AWS, the 2 vCPUs consist of one physical core with two threads, not shared with other customers (AWS). OVH guarantees resources for the family to which the c3 instance belongs (OVHcloud). Scaleway BASIC3 has shared vCPUs (Scaleway), and in Milan, dedicated vCPUs aren’t available in all three zones: for a three-zone cluster, the shared option is the only choice. That’s why I chose it. Steal. I measured steal on all three during the same tests. Steal is the time the vCPU wants to run but the physical server has given the core to another machine. On AWS and OVH, it’s practically zero. On Scaleway, it ranges from about 1% to 13%, depending on the node and the workload. Disks. OVH uses a local NVMe drive, which the pricing sheet refers to as “ephemeral”: it is not replicated (pricing sheet). This is fine for etcd, since it already maintains three copies of the data, one per zone; for a database, it’s a different story, and we’ll explore that in a dedicated experiment. Scaleway uses a network-attached disk replicated in three copies (Scaleway). AWS uses gp3, which includes 3,000 IOPS (AWS): to ensure a level playing field with Scaleway, which has 5,000 IOPS disks, I paid for 2,000 extra IOPS. The Milan zones: network, disk and writes A note on this section: the performance differences described below are significant with high data volumes or under database stress; with normal use, you won’t notice them. Failover behavior, however, affects everyone. All three providers describe their zones as separate data centers: AWS, OVHcloud (and the Milan page), and Scaleway. Details regarding distances and independence are often general, not specific to Milan, so I’ll limit myself to what I’ve measured. Network !Latency between each pair of zones and single-transfer bandwidth, in Milan, on AWS, OVHcloud and Scaleway Top: round-trip time between each pair of zones, typical case (p50). Bottom: bandwidth of a single transfer between two nodes in different zones. The first panel matters for etcd: every write operation waits for a response from another zone, so cross-zone latency is factored into every write. Here, it ranges from 0.5 to 1.4 ms across all three providers, and none stands out. The second panel measures performance when moving large amounts of data, such as database replicas and backups. OVH achieves between 3.7 and 4.1 Gbit/s; Scaleway manages 0.36 Gbit/s, which is the stated limit for this instance size, not for its network. AWS achieves 4.96 Gbit/s across all three pairs, but this needs to be interpreted carefully: it’s the 5 Gbit/s cap that AWS imposes on a single data stream (AWS). The guaranteed bandwidth for this instance is 0.78 Gbit/s, with peaks of up to 12.5 Gbit/s that typically last between 5 and 60 minutes (AWS). My ten-minute test fell within the peak period, so this doesn’t indicate how well it handles a long-duration transfer. On AWS, cross-zone traffic is charged at $0.01 per GB in each direction, approximately 0.9 euro cents (price list). OVH does not charge for traffic on its private network (OVHcloud). Disk !Disk fsync time, p50 and p99, per node, and the same measure as seen by etcd fio is the standard tool for measuring disks. The fsync test measures how long the disk takes to confirm that data has really been written, rather than left in memory. Filled dot: p50, the typical case. Hollow dot: p99, the worst case in a hundred writes. The bottom panel is the same measure seen from inside etcd, at p99. This is the metric that matters most for etcd, because etcd does not acknowledge a write until the disk confirms it has been saved. OVH does 0.34 ms, with a p99 of 0.43: local NVMe, and it shows. AWS hovers around 3 ms, and even the slowest writes stay close to that, with a p99 of 3.4: it’s the most consistent network disk I’ve measured. In the typical case, Scaleway is faster than AWS at 1.1 ms, but one in every hundred writes takes 6-9 ms, and from etcd’s perspective, it reaches 12 ms. However, these numbers don’t mean one disk is better than the other: they’re two different things. OVH uses a local disk attached to the physical server: extremely fast, but the pricing sheet calls it “ephemeral”; it isn’t replicated, and if the server fails, the data on that disk isn’t guaranteed. Scaleway and AWS use network-attached disks, which sacrifice some speed but offer other benefits: - the data survives the machine: if the physical server fails, the disk is attached to a new machine in the same zone; - they are replicated: Scaleway keeps three copies of all data (Scaleway), and AWS replicates the data from each disk across multiple servers in the same zone (AWS); - they can be detached and moved: you can reattach them to another machine, scale them up, or save them with a snapshot, without touching the server; For etcd, which already maintains three copies across three zones, the fast local disk is the ideal choice. For a database with a single copy, or for app data, the network disk can save you when the machine fails. It depends on what you store on it. OVH also sells network disks separately, which I haven’t measured here. And neither survives the loss of the entire zone. Writes on Kubernetes !Latency of a write to the Kubernetes API, p50 and p99, by leader zone How long Kubernetes takes to confirm it has saved data, from when the probe sends it to when the reply arrives. Everything is in there: CPU, the network to the other zones and the disk. The probe always writes to the API in the first zone; each row is a run with the leader moved to the zone shown. The axis goes in multiples of ten (1, 10, 100 ms), so fast and slow writes show up together. Here you can see everything together. A write operation takes 2.8-3.6 ms on OVH, 3.4-5.0 ms on AWS, and 4.9-6.3 ms on Scaleway. The p99 is under 9 ms on AWS and OVH. On Scaleway, it’s 18-19 ms, except in one test, the one with the leader in it-mil-1, where it reaches 97 ms. It doesn’t depend on the zone: in another run, the same test stopped at 16 ms. In that minute, slow writes were simply more frequent. The interesting detail is the contrast with the disk performance graph: in the typical case, Scaleway has a faster disk than AWS, but Kubernetes takes longer to confirm a write. So the disk alone doesn’t explain it. To understand where Scaleway’s slow writes come from, I ran an additional round of tests, only there, measuring the steal and the disk every 100 ms. The result: it’s both, playing different roles. When the node receiving the writes has to wait for the CPU, because the physical server is giving it to another machine, the probability of a slow write rises from 0.35% to about 9%. The spikes above 100 ms, on the other hand, come from the network disk, which occasionally stalls for tens of milliseconds. When both issues occur simultaneously, more than one in four writes is slow. The node receiving the writes is the critical factor, while the leader node matters much less; and with the added traffic from the test app, slow writes increased by about half. With small, shared machines, it’s therefore best not to load that node with other work. How I simulated the loss of a zone I didn’t shut anything down: I isolated a zone from the network using nftables. Its nodes remain powered on, but they don’t communicate with anyone, and no one communicates with them. This is sufficient to simulate the loss of a zone: for the rest of the cluster, a shut-down zone and an unreachable zone are the same thing. In both cases all you get is silence, and neither etcd nor Kubernetes can distinguish between them. In fact, isolation is the most challenging scenario, because the isolated nodes are alive and continue to try to operate. What it doesn’t simulate: the provider’s services in that zone, namely network disks, APIs and load balancers, remain up. And I don’t test partial failures, such as a slow zone or one that drops packets, which are a different type of failure. During isolation, only the SSH port to my address remains open so I can intervene; the cluster doesn’t use it, and the rule removes itself automatically when it expires. For the second failure, I simulated a crash: the leader node suddenly reboots without writing anything to disk. Like a server losing power. During the failure, a probe continuously writes to the Kubernetes API from a zone I don’t touch, with a 2-second write timeout, and measures how long writes stay blocked. It measures only the writes. Meanwhile, a test app is running: a small web server with three replicas, one per zone, accessible via a single internal address. From a healthy node, a client continuously calls them, one request at a time, and marks any request that doesn’t respond within 2 seconds as failed. I forced one replica per zone, and that matters later: that’s why the lost replica doesn’t restart in another zone. The zone remains isolated for 7 minutes because Kubernetes gives up on a lost node after about 6 minutes, and I wanted to see that happen. I repeated each failure three times per provider. Everything else is left at its defaults, because that is what someone installing K3s today would get. The cluster survives, and the timings are the same everywhere On all three providers in Milan, as well as on Hetzner, the cluster loses a zone and continues to function, three tests out of three. The graph shows three different tests, from top to bottom: - leader zone isolated: I isolate the zone where the leader is located. The other two copies of etcd can no longer communicate with it; they wait and then elect a new leader. - leader crash: the leader node suddenly restarts. Here, too, the remaining copies must elect a new leader. - zone without leader: I isolate a zone where the leader is absent. The leader still holds the majority, two copies out of three, and continues to operate: no election takes place. The pauses range from 0.03 to 0.07 seconds, which is why the data points are all close to zero. !Seconds of write pause by failure type, three runs per provider Each dot is a run: how many seconds writes on Kubernetes stay blocked. When an election is needed, Kubernetes does not accept writes for 6-10 seconds, then resumes on its own, always with a single leader change. This is the time etcd waits before considering the leader lost and electing a new one. K3s sets this time longer than normal to accommodate slow networks, and etcd intentionally varies it slightly with each election. This is why the same provider shows 6 seconds in one test and 10 in the next. The values are always 6.1, 8.1, or 10.1 because my probe retries every 2 seconds. So there is no ranking to be made. Out of 30 failures across all providers, including Hetzner, the pauses split as chance predicts: 13, 13, and 4 times, against the expected 15, 12, and 3. The details are in the repository. These times can be reduced, but with slower networks, spurious elections become more frequent. I left the default settings because that’s what anyone installing K3s will encounter. And Scaleway’s shared vCPUs have nothing to do with this: etcd determines the times, not the machine. What your app sees The fact that the cluster survives is good news for those who manage it. But anyone running an app on it wants to know something else: what users see. There are two delays that matter. Kubernetes takes about one minute to stop sending traffic to a failed zone, and about 6 minutes to rebuild elsewhere what was there. An app with three replicas only experiences the first. A component that exists in a single copy experiences the second. The replicas in healthy zones continue to respond. But until Kubernetes marks the node as lost, between 43 and 78 seconds after isolation, it continues to send requests to the failed replica as well. In my tests, during that window, between a quarter and half of the requests failed, about one in three, and each failed only after waiting the 2-second timeout. It’s not the app that goes down, but for that minute, one in three requests hangs and then fails. I haven’t measured it, but the simplest fix lies with the client: a short timeout and a retry, which will likely hit a healthy replica. After about 6 minutes, between 344 and 379 seconds, Kubernetes gives up on the node and deletes the lost replica. But it doesn’t recreate it elsewhere: I’ve set it to one replica per zone, so it waits for the zone to come back online and recreates it there. When the zone comes back online, everything realigns within a minute and a half. What K3s installs as a single copy There’s one thing I had taken for granted: that a cluster spanning three zones would be highly available in all its parts. That’s not the case: K3s deploys three components as a single instance (CoreDNS, Traefik, and metrics-server). If the lost zone is the one where they’re running, the cluster holds up but they don’t, until Kubernetes recreates them elsewhere after those 6 minutes, or until the zone comes back. | Component | What stops working | For how long | | --- | --- | --- | | Traefik, the ingress | the app with three replicas is not reachable from outside | 352-376 s in Milan, up to 379 s on Hetzner; checked from inside the cluster, from a healthy node | | metrics-server | kubectl top, and pod autoscaling is left without data | 395-409 s in Milan, from 372 s on Hetzner | | CoreDNS, the internal DNS | no names in the cluster: anything that reconnects by name waits | until the zone returns or it is recreated elsewhere; measured in earlier runs, before the fix | In practice: three replicas across three zones are useless if the only ingress is in the lost zone. The app is up and running, but no one can reach it from the outside for 6 minutes. The DNS issue came to light during database testing: when the zone running the DNS was lost, a replicated database remained down until the zone came back online, instead of restarting in just over a minute. I’ll come back to this when I discuss databases. That’s why, in all the tests in this article, CoreDNS runs in three replicas. High availability must also be ensured for components you didn’t install yourself. One zone can become more important than the others without anyone having decided it. !Timeline of the test app and K3s components while a zone is isolated Seconds since the isolation began; the zone returns at 420 s. The first two rows are the test app, the last two the single-copy K3s components, which in these runs were in the lost zone. Solid bar: the fastest run; faint: the slowest. "Replica evicted" is a moment, not a duration: it is when Kubernetes gives up on the node, and only from then do Traefik and metrics-server restart elsewhere. Had the zone come back sooner, they would have come back with it. Hetzner: three cities are not three zones Hetzner does not have availability zones within a single data center, and as far as I can tell, it has not announced any plans to implement them (Locations, What’s New). To have three “zones,” I used its three European data centers: Falkenstein and Nuremberg in Germany, and Helsinki in Finland. There are no other locations in Europe, so there wasn’t a closer option. The comparison with Milan isn’t on equal footing, which is why Hetzner stands apart. Two machines: cpx22, with 2 shared vCPUs and 4 GB of RAM, the same size as in Milan; and ccx13, with 2 dedicated vCPUs and 4 GB of RAM, as a control. Why the cpx22 and not the CX23, which costs less: The Cost-Optimized series is available in limited quantities; during my tests, the CX23 was unavailable. Even if I had waited for it to become available, it would have made it very difficult to replicate the experiment given how infrequently it’s available across all three zones. The CPX series appears to be Hetzner’s standard offering, running on next-generation hardware (Hetzner). The cluster performs as it does on the others, with the same 6-10 seconds, and the app also behaves as it does in Milan: traffic rerouted in 44-73 seconds, lost replica removed after about 6 minutes. The dedicated vCPUs do not affect the failure times, because those are determined by etcd. !Hetzner: disk by city, bandwidth between Falkenstein and Nuremberg, and writes by leader city, cpx22 and ccx13 Top: disk by city. Middle: bandwidth between Falkenstein and Nuremberg in one of the three cpx22 clusters; the other two gave 4.9 and 0.26 Gbit/s. Bottom: a write on Kubernetes by the city where the leader is. You buy the machine, but not the distance. At the two German locations, the ccx13’s disk is about four times faster than the cpx22’s: 0.27 ms versus 1.1-1.2 ms. Even the slowest writes on Kubernetes, the p99, drop to one-third: 7-9 ms instead of 21-23 ms. In Helsinki, however, the ccx13’s disk performs like the cpx22’s, at about 1 ms. But with the leader in Helsinki, every write takes 63 ms on both machines, 6 to 12 times the normal time. The reason lies in the majority rule. A write is confirmed when two out of three copies have it. With the leader in Germany, the other German node is sufficient, at 3 ms. With the leader in Helsinki, a node in Germany is required, at 24-36 ms. After a failure or a reboot, the leader may end up in Helsinki, and there’s no way to prevent it: it can only be moved manually. On Hetzner, moreover, a single test isn’t enough. Three cpx22 clusters created on the same day yielded bandwidths between Falkenstein and Nuremberg of 4.9, 0.26, and 1.6 Gbit/s: every new cluster lands on different physical servers. List prices for new orders, as of October 30, 2026, excluding VAT: cpx22 at €19.49 and ccx13 at €42.99 per month, plus €0.50 per IPv4 address per server (source). These apply to new orders since June 2026; servers activated earlier may pay less. Internal traffic is free (Hetzner). With the cpx22, the cluster costs about €60 per month, roughly half the price of the others. With the ccx13, it’s about €130, more or less the same as OVH in Milan: “Hetzner costs half as much” applies only to shared vCPUs. What three zones cost The true cost of three zones lies in the price of the machines: latency between zones adds only a few milliseconds to write operations. | 3-node cluster | Per month | | --- | --- | | AWS, c7i.large | about €259 | | OVHcloud, c3-4 | about €122 | | Scaleway, BASIC3-X2C-4G | about €109 | On-demand list prices as of October 30, 2026, excluding VAT, with disk and IPv4 included. AWS prices are converted from dollars to euros. On OVH in Milan, the local disk and IP are billed separately from the instance and are included in the total. AWS costs a little more than double: about 2.1 times OVH and 2.4 times Scaleway. Additionally, on AWS you pay for cross-zone traffic, which is included on OVH. What you get with the price difference on AWS: the most consistent network disk I’ve measured; non-shared vCPUs; and everything I didn’t use: EKS, RDS, and managed services. If you use them, you’re also paying not to build by hand what this article describes. Bandwidth, on the other hand, I wouldn’t count as a definite advantage: the guaranteed bandwidth for this instance is 0.78 Gbit/s, and my 4.96 falls within the peak range. Two caveats. These are list prices, without any discount plans. And another family of machines on AWS, such as t3 or Graviton, would change the ratio. Mistakes made while measuring Before publishing, I found and corrected three errors. 1. The probe was also measuring the connection. It opened a new TLS connection with every write, and writes to Kubernetes were 1.5-3 ms slower across all providers. I corrected and reran everything. 2. The DNS was in a single replica, the story told above. I noticed this because some tests took twice as long as others; I kept only the data with three replicas. What this article does not cover - Three repetitions per provider: these demonstrate the behavior; they are not statistics. - The probe measures at intervals of about 2 seconds, and only writes: I didn’t measure reads during the election. - This isn’t a true zone failure: I isolate the nodes, but network disks, the provider’s API, and the load balancer remain up. I didn’t test partial failures, such as a slow zone or one that drops packets. - Small machines, no real load during the failure. - On AWS, only machines: no EKS or RDS. - Outside of this scope: the database, app volumes, and how traffic arrives from the outside, that is, load balancers and public DNS, which I’ll address with dedicated experiments. Conclusions Where a provider offers three nearby zones, there’s no reason to forgo high availability: it all depends on the software built on top of it. On OVH and Scaleway in Milan, the cluster withstood the loss of one zone in all tests, just as it did on AWS. If the leader is in the lost zone, writes stop for 6-10 seconds, the same across all providers; otherwise, there is barely any pause. The differences lie elsewhere: in the disk, the CPU, and the price, which must be chosen with a clear understanding of what you’re buying. On Hetzner, where the zones are three cities, and with the leader in Helsinki, you pay the price for the distance with every write. And in the components that K3s installs as a single copy, which make any given zone the one you simply cannot afford to lose. For Flui, this moves the problem. Three zones across European providers are a viable option, and the cluster stands on its own. High availability depends on what’s above it: the system components, which must have a copy in every zone, and then the databases and volumes, which must survive the loss of a zone. This is the work Flui must do on behalf of its users. The next step is the database itself: Postgres across three zones, how much it costs not to lose a commit and how long it stays down. The scripts and data are in the dawit-io/ha-eu-bench repository, along with write-by-write data for every run and the source of every figure quoted. Flui is at flui.cloud, and its code is on GitHub. Originally published on my blog, where you’ll also find the Italian version.

  3. YouTubeYtGuruji · YouTube description · 110 likes · 30 comments · 11,562 views

    1.3 billion Claude Code tokens free Just use unlimited no need for Subscriptions 1.3 billion Claude Code tokens free Just use unlimited no need for Subscriptions In this comprehensive claude ai tutorial, learn how to use claude code completely free without paying for expensive plans! If you want to use claude code for free, this step-by-step guide covers the full claude code setup process using open GitHub repositories and terminal commands. Discover how to set up claude code free api integration with free NVIDIA API access to unlock free ai tokens (up to 1.3 billion tokens per month). Get claude code unlimited usage and access claude code without subscription directly in Claude Desktop, OpenCode, VS Code, and Antigravity. This complete claude code hindi walkthrough shows you everything you need to run free claude code smoothly. If you are looking for claude free unlimited access and claude code free unlimited tokens, watch the entire video to configure your environment correctly! #ClaudeCode #ClaudeAI #ClaudeCodeFree #FreeAITokens #ClaudeTutorial #AITools #ClaudeCodeHindi Video chapters 00:00 – Introduction: How to use Claude Code & overview 01:09 – Free Claude Code GitHub repo & free AI tokens (1.3B tokens/month) 02:19 – Claude Code setup via PowerShell & terminal commands 03:52 – Claude Code free API setup with NVIDIA keys 05:06 – Admin panel & connecting Claude Code without subscription 06:17 – Claude AI tutorial: Testing Claude Code free unlimited 07:44 – Claude Code Hindi demo & final tips Feel free to tweak any links or social handles you'd like to add! Things i used Nikon d5300 -amzn.to Boya Mic -amzn.to Tripod -amzn.to ringlight -amzn.to Link -Alishahryar1/free-claude-code Our some other videos Playlist - Our Social Links- Youtube - youtube.com Facebook- .facebook.com Twitter- twitter.com instagram- instagram.com

  4. Location: Jaipur, India Remote: Yes (Global Remote / Independent Contractor / W-8BEN) Willing to relocate: No (Remote only) Technologies: Java (8/11/17), Python, AWS (EKS, ECS, S3, SQS), Apache Kafka (CDC), PostgreSQL (pgvector), Docker, Kubernetes, Terraform, RAG Architecture, AI Agents (MCP) Resume: linkedin.com (full resume can be shared on request) Email: kimeshgupta@gmail.com GitHub: Kimesh/nexusflow-analytics LinkedIn: linkedin.com Senior Software Engineer & Distributed Systems Consultant with 8+ years of production experience building high-scale data pipelines and enterprise infrastructure (ex-BlackRock, OnGrid, Norstella). Recent Highlights: • Enterprise Scale: Engineered multithreaded batch processing and Kafka CDC pipelines driving $500K/year in client revenue and reducing DB load by 35%. • Cloud Cost Optimization: Consolidated AWS EMR clusters and automated S3 lifecycle rules, saving $110,000/year. • AI & Compliance Infrastructure: Architected production RAG pipelines with PostgreSQL (pgvector) and autonomous agentic workflows (ReAct/MCP) eliminating hallucinations for financial auditing. • Security & Governance: Remediated system-wide VAPT vulnerabilities to secure SOC 2 compliance. Available immediately for high-impact backend, platform, and AI engineering contract roles ($40–$60+/hr).

  5. Redditu/middayc · r/ryelang · 3 points

    Output-intent, input-intent ... or a Runtime Effect-like System? I was quite enthusiastic about the idea of output-intent and input-intent when I created it ... dry-run mode, scenario mode, etc ..., but ti didn't really click with any of the readers/users. I keept working on this, exploring the subject, and came to languages with effect systems. With languages like Koka, Unison, OCaml ... these are mostly strongly typed functional languages, bordering research languages. And there the effect system is based on types, ... to say ... it's not really runtime dynamic, like Rye is. Rye is a runtime homoiconic language and the effect-related-system (yes, I changed the word intent for effect, so now we have input-effect and output-effect) is also fully runtime oriented ... i.e. dynamic. I saw some related ideas, not in general purpose dynamic languages, but things like Terraform and Ansible. This made me add rye CLI flags --eff-ask and --eff-confirm These are very simple flags, but add a lot to Rye runtime behaviour. Meaning, you can use a normal Rye script in fully new ways, with new guarantees, checks and options. Minimal example of using --eff-ask mode: --useLinux >> cat 05-ask.rye ; Run: ; rye -eff-ask 05-ask.rye ; ; Press Enter to keep the provided value, or type a new value. ; Typed value is checked with the same validation dialect. port: input-effect 'port { integer } { first Load %.port.val } print join [ "Using port: " port ] --useLinux >> rye 05-ask.rye Using port: 8080 --useLinux >> rye --eff-ask 05-ask.rye port [8080]: HELLO invalid port: not integer port [HELLO]: 1234 Using port: 1234 And example of using --eff-confirm --useLinux >> cat 04-confirm.rye ; Run: ; rye -eff-confirm 04-confirm.rye ; ; Answer y to run an effect, or n/just Enter to skip it. output-effect 'first "one" { print "ran first effect" } output-effect 'second "two" { print "ran second effect" } print "Script finished." --useLinux >> rye 04-confirm.rye ran first effect ran second effect Script finished. --useLinux >> rye --eff-confirm 04-confirm.rye run first: one? [y/N] run second: two? [y/N] y ran second effect Script finished. I hope you see some use in this, because I sure do :) ... Both ask and confirm modes should also allow have option where you can ask / cofirm just specific effect blocks. For a large script you probably don't want to provide all the inputs, but just some. Or confirm all the outputs. There are plenty more ideas, also for audit of effect, and mode where code needs to have all efecting functions inside effect blocks, but this is multiple iterations in the future still. What you see above should be available in Rye v0.2.81 release, so follow us on: refaktor/rye

  6. X@shotcutapp · 10 likes · 2 reposts · 301 views

    There is a new beta for the upcoming 26.11 release github.com/mltframework/shotcut/releases/tag/v26.… It fixes many things that regressed in recent months plus some old bugs. Only big new feature is an Audio Mixing Assistant. t.co

  7. X@bern_jaeger · 6 likes · 1 repost · 282 views

    🚘 Today KE:SAI is releasing Latent TF-K1, an autonomous driving model that is competitive with NVIDIA Alpamayo 1 across 6 public benchmarks, but trained with 44x less data and ~1000x less compute. 📜 Blog: kesai.eu ⭐GitHub: kesai-labs/py123d_garage t.co

  8. Hacker Newsjoe-esquibel · 4 points · 3 comments

    Show HN: The DNA of DOOM – How code structure survives across 44 ports I used my custom built structural extraction engine to analyze 44 DOOM ports across history to see what functions remain, if the keyword structure of those functions remained, if comparable call networks could be seen, etc. - squid-protocol/gitgalaxy

  9. Bluesky@seav4f.bsky.social · 3 likes · 1 repost

    The venerable #JavaScript mapping library Leaflet just released the first beta of v2! 🎉 github.com/Leaflet/Leaflet/releases/tag/v2.0.0-be… The last stable version, v1.9.4, was released in May 2023.

  10. DEV@null_saint · 10 reactions

    Inside Software PLCs: How They Work and Where Security Boundaries Begin By RUGERO Tesla (@404Saint). Why I Started with the Foundations When I finished my industrial protocol research series, I wanted to move closer to the systems using those protocols. I turned my attention to software PLCs and started investigating OpenPLC Runtime v4. My first investigation quickly took me into runtime internals and the Linux environment supporting them. There was a lot to learn, but I eventually realised that I was spending more time understanding implementation details than answering the security questions I had originally set out to explore. I stepped back and reorganised the project. Before investigating how software PLCs could be attacked, I wanted to understand what they actually are, how they operate, and how their different components fit together. That became Part I: Software PLC Foundations. Understanding the Software PLC A Programmable Logic Controller (PLC) is an industrial computing system responsible for monitoring inputs, executing control logic, and controlling outputs connected to a physical process. It receives information from devices such as sensors, evaluates that information against its programmed instructions, and sends commands to equipment such as motors, pumps, and valves. Traditionally, PLC functionality has been delivered through dedicated industrial controller hardware. A typical controller brings together a CPU, memory, system software, communication interfaces, and connections to industrial I/O. Depending on the platform, these components may be integrated into a compact unit or arranged as a modular system. A Software PLC (SoftPLC) implements the same fundamental control functionality through a software runtime operating on a compatible computing platform. That platform might be an industrial PC, an embedded computer, or another supported computing environment. This contrast became the starting point for my first investigation. A software PLC still relies on physical hardware. What changes is how the controller functionality is implemented and how it relates to the underlying computing environment. In a traditional PLC, the manufacturer generally delivers the controller as an integrated platform with its own firmware, execution environment, and supported hardware interfaces. In a SoftPLC, the runtime depends more directly on the host platform. The operating environment supplies computing resources and system services, while the runtime provides the environment for loading and executing the control application. !Traditional PLC vs. Software PLC Architecture Figure 1. Architectural comparison of traditional hardware PLCs and software PLCs. That separation introduces some interesting possibilities. Software PLCs can offer more flexibility in hardware selection and integration with other software systems. It also means that the host operating environment becomes part of the controller's architecture and something we need to understand when examining its security. The deployment model adds another layer to this picture. A software PLC can run directly on a host operating system, use a real-time operating environment, or operate inside a virtual machine or container. These arrangements are quite different. A virtual machine provides a guest operating system over virtualised hardware managed by a hypervisor. A container packages and isolates application processes while sharing the host operating system's kernel. !Software PLC Deployment Models Figure 2. Common deployment environments for software PLC runtimes. That difference is important. The isolation provided by a container is not the same as the separation between a virtual machine and its host. Access to devices, network interfaces, filesystems, and host resources also depends on how the environment is configured. I also wanted to understand the assumptions around execution timing. There is a tendency to associate deterministic control exclusively with dedicated PLC hardware, as though running control software on a general-purpose platform automatically makes predictable execution impossible. The reality is more dependent on the complete configuration. Processor resources, scheduling, operating system behaviour, runtime implementation, I/O handling, and competing workloads all influence execution timing. Virtualisation does not automatically rule out predictable execution either. Research examining virtual PLC implementations has demonstrated that comparable timing behaviour is achievable under particular tested configurations. That does not mean every virtualised deployment will meet every industrial timing requirement. The intended application and the complete system still have to be considered. There is also the physical environment to account for. An ordinary computer running PLC software should not automatically be treated as equivalent to industrial-rated controller equipment. Environmental conditions, supported interfaces, power requirements, and equipment qualification remain relevant. By this point, the contrast between a hardware PLC and a SoftPLC was becoming much clearer. I could also see why identifying the deployment environment was important before making assumptions about the security of a particular implementation. From Control Logic to a Running System The computing platform provides somewhere for the PLC runtime to operate, but the runtime needs a control application to execute. Industrial control applications are commonly developed using the programming languages defined by IEC 61131-3. These include Structured Text (ST), Ladder Diagram (LD), and Function Block Diagram (FBD), alongside Sequential Function Chart (SFC) elements used to organise sequential operations. The languages provide different ways of expressing control behaviour. Structured Text uses a textual syntax, Ladder Diagram represents logic through graphical electrical-style elements, and Function Block Diagram connects functional blocks to describe operations. SFC provides a way to organise sequences through steps and transitions. The standard also defines how control applications can be organised through Program Organization Units (POUs). Programs, functions, and function blocks provide different building blocks for structuring application logic. A function block, for example, can retain internal state between executions, which makes it useful for representing operations that need to remember previous conditions. Understanding these structures helped me move beyond thinking of a PLC program as one large block of instructions. A control application can contain several interconnected pieces of logic, each contributing to the behaviour of the overall system. There is also a process between writing that logic and having it run on a controller. This is where the engineering lifecycle becomes important. An engineering workstation is used to develop and configure the application. Depending on the platform, the project may then pass through compilation or code generation before being transferred to the target PLC runtime. The runtime loads the resulting application and makes it available for execution. The engineering environment often remains involved after deployment. Engineers may use it to monitor variables, inspect controller status, modify application logic, or perform online changes where the platform supports them. Projects also need to be backed up, maintained, and recovered when something goes wrong. !PLC Engineering and Program Lifecycle Figure 3. Simplified lifecycle of a PLC control application. I found this part particularly important because the engineering project, generated application, and program currently loaded on the controller are related, but they are not necessarily identical artefacts. Platform-specific compilation, project formats, libraries, and deployment procedures all affect how an application moves through its lifecycle. Interchange standards such as IEC 61131-10 also address the exchange of PLC project information using XML. That provides a basis for exchanging engineering data, although it does not guarantee that projects will behave identically across different runtimes and vendor environments. Once the application reaches the runtime, another important contrast appears: how the program is executed. A familiar PLC execution pattern is the scan cycle. The controller reads input states, evaluates the control logic, and updates outputs before repeating the cycle. This provides a useful way to understand basic PLC operation, although actual execution models vary. Some platforms support multiple tasks with different priorities, intervals, or triggering conditions. !PLC Program Execution Cycle Figure 4. Simplified PLC scan cycle and interaction with the industrial process. The runtime is responsible for coordinating this execution according to its implementation and configuration. Timing requirements become especially important here. A control application that produces the correct logical result may still be unsuitable for its intended process if it cannot execute within the required time. This also explains why runtime scheduling, resource availability, and watchdog mechanisms matter. They contribute to how the controller behaves during normal operation and how it responds when execution does not proceed as expected. Taken together, the programming model, engineering workflow, and execution environment describe how control logic travels from an engineering project into a running industrial controller. They also reveal several points where the integrity and availability of that application matter. Looking at the System Through a Security Lens By the time I reached the final investigation, the different pieces of the architecture were starting to connect. A software PLC depends on its host platform. The host supports the runtime, the runtime executes the control application, and the application interacts with the industrial process through supported I/O and communication interfaces. The engineering environment provides another route through which the application is created, configured, and maintained. Each relationship establishes a boundary worth examining. !Software PLC Security Boundaries Figure 5. Architectural components and security boundaries in a software PLC environment. At the platform level, operating system privileges, user accounts, filesystem permissions, and process isolation influence what the runtime and its supporting services can access. Where containers or virtual machines are involved, their configuration introduces additional isolation boundaries and dependencies. At the application level, the integrity of the control program matters because its instructions determine how the controller responds to the process. The engineering workstation and program deployment workflow therefore deserve attention alongside the runtime itself. An assessment that only looks at the PLC host can miss important parts of how control logic is developed and delivered. The communication side introduces another set of considerations. Management interfaces may support configuration, monitoring, and program deployment, while industrial communication interfaces allow the controller to exchange data with other systems. These interfaces have different purposes and may have different security requirements. Availability also deserves attention. A software PLC may share processor time, memory, storage, and other resources with services running on the same host. Depending on the deployment, resource pressure or failure of a supporting component could affect runtime operation. This is where the six investigations came together for me. The security boundaries of a software PLC cannot be understood by looking at the runtime in isolation. They emerge from the relationship between the deployment environment, the control application, the engineering process, and the interfaces connecting the system to its surroundings. I used standards, manufacturer documentation, academic publications, and implementation documentation throughout Part I. OpenPLC Runtime v4 served as a useful practical reference when I needed to examine how some of these architectural ideas appear in an actual implementation. I kept its specific design separate from general SoftPLC concepts, since one implementation cannot represent every platform. I also tried to keep documented behaviour, observations from the lab, and my own technical interpretations distinct. That contrast is important when drawing security conclusions. An exposed interface or a process running with elevated privileges can be relevant to an investigation, but its presence alone does not establish a vulnerability or demonstrate what an attacker can achieve. The goal of this first part was to establish the system context needed to ask better security questions. What's Next? With Part I complete, the research moves into Part II: Attack Techniques. The next stage will examine established techniques involving PLC program and configuration tampering, runtime manipulation, and execution disruption. The focus will be on understanding what these techniques can achieve against software PLC environments and gathering evidence of their actual impact. The work from Part I gives me a much better starting point for those investigations. I also intend to retain and use the earlier OpenPLC implementation work wherever it helps answer a relevant security question. --- Explore the Research This article brings together the main ideas from Part I, but there's more behind it. I've documented the individual investigations, technical details, diagrams, and supporting material in the project repository. You can explore the research on GitHub: 404saint/softplc-security-research.

  11. X@generaltensor · 13 views

    3. UPDATE from @opentensor: an open Subtensor PR fixes audit findings from Yubo and ReinforcedAI, including childkey take charged to the wrong pool, lock transfers during subnet dissolution, and nested Utility batches hidden behind wrapper calls. subtensor#3297

  12. X@arunimastwt · 2 likes · 1 repost · 44 views

    @ycombinator If you're building agents and want to help shape this, try AgentSec on yours and tell me what breaks: pip install invaris-agentsec agentsec init agentsec test invarislabs/invaris-agentsec

  13. Delete Customer Vectors for GDPR: A Node.js Account Closure Ledger TL;DR: A B2B listing aggregator should treat its own tenant-to-document ledger as the deletion authority. On account closure, read every document ID for that customer from the application database, delete those vector IDs, query for text unique to the removed listings, and close the erasure request only after the query returns nothing. Keep a compact audit record of the IDs, outcome, and timestamp; do not retain the deleted listing text merely to prove that it was deleted. This design favors evidence over convenience. A vector index cannot enumerate a customer's data for the application, and a successful delete response alone does not establish that retrieval stopped returning it. Chunking and freshness make the boundary harder: one listing may produce several vectors, while refresh jobs may still be ready to write an older snapshot back. How should Node.js delete all customer vectors during GDPR account deletion? The account database knows ownership. The vector index knows retrieval. Conflating those roles creates an erasure process that depends on metadata filters being complete, consistently spelled, and present on every historical chunk. For a listing aggregator, the useful unit is a ledger row such as (customer_id, source_id, listing_id, document_id, revision, indexed_at). A source listing split into six chunks should create six document IDs, all tied to the same customer and revision. If a later refresh produces four chunks, the transaction that activates the new revision should also retire the six old IDs. Account deletion then becomes a bounded database lookup rather than a search for labels that may have drifted. That choice has a telemetry consequence. Logging the full payload again makes the deletion trail larger and preserves material that the request meant to erase. Log identifiers and state transitions instead. For 80,000 deleted chunks, 80,000 high-cardinality log events are usually a poor default; one request record plus paged child records in an access-controlled audit table is easier to reconcile and apply retention to. Cardinality is a budget. The race with ingestion also needs an explicit boundary. Mark the tenant deleting before reading the ledger, reject new indexing work for that tenant, and invalidate queued refresh work by checking the tenant state at execution time. Then take the ID snapshot. Without that sequence, a worker can recreate a vector between deletion and verification even though every individual API call behaves correctly. Order matters. Derive the workflow from the erasure invariant The invariant is small: after the operation, no active ledger row or retrievable vector belongs to the customer. The workflow follows from it. 1. Put the account into a deleting state and stop future source refreshes. 2. Read all of its document IDs from the application tables, including inactive revisions that remain inside the vector store. 3. Delete by ID in bounded batches. Record the request ID, document IDs, attempt, result, and timestamp. 4. Query with distinctive text from the removal set and assert that nothing returns. 5. Remove the application records covered by the request, retain only the audit evidence allowed by policy, and close the request. The short step is step four. It is also the one teams are tempted to omit. Infrai is a reasonable fit when the service boundary should remain a plain REST API: Node.js needs no vendor SDK or client-library version, and the same bearer-key convention can cover the calls. Infrai uses one key for 295 routes across 20 modules and consolidates them on one bill. A deletion worker that already uses adjacent backend capabilities therefore does not need another credential or invoice owner merely for vector cleanup. Its public discovery surface is self-describing and requires no key, so a build step can obtain the current request and response JSON Schema instead of freezing fields from an article. That reduces contract drift in this deletion job, where an invalid payload should fail before the account workflow begins. The verified vector surface includes deletion and query operations. Because the supplied request fields should come from that current schema, the shell below accepts schema-valid JSON files generated by the application and exercises only those two routes. set -euo pipefail : "${INFRAI_API_KEY:?Set INFRAI_API_KEY}" : "${INFRAI_BASE_URL:?Set INFRAI_BASE_URL}" : "${DELETE_BODY:?Set DELETE_BODY to a schema-valid JSON file}" : "${QUERY_BODY:?Set QUERY_BODY to a schema-valid JSON file}" curl --request DELETE \ --url "${INFRAI_BASE_URL}/vector/delete" \ --header "Authorization: Bearer ${INFRAI_API_KEY}" \ --header "Content-Type: application/json" \ --data-binary "@${DELETE_BODY}" \ --fail-with-body \ --retry 5 \ --retry-all-errors \ --retry-max-time 60 curl --request POST \ --url "${INFRAI_BASE_URL}/vector/query" \ --header "Authorization: Bearer ${INFRAI_API_KEY}" \ --header "Content-Type: application/json" \ --data-binary "@${QUERY_BODY}" \ --fail-with-body \ --retry 5 \ --retry-all-errors \ --retry-max-time 60 curl retries transient failures and HTTP 429 responses; when the server supplies Retry-After, curl uses it. --fail-with-body preserves a 4xx response body for diagnosis while returning a failing exit status. The orchestration must still be idempotent: keep the ledger row until deletion and verification have succeeded, so a restarted job submits the same IDs rather than guessing what remains. Verification should use a query payload built from distinctive text already held for the pending request. Test several removed listings when the tenant is large, including an old revision and a recently refreshed one. A zero-result assertion is the close condition. If the query returns a removed document ID, do not close the request; repeat deletion for that ID and investigate which writer remained active. Chunking and freshness determine the blast radius Chunk IDs should be deterministic from stable inputs, for example the tenant, source listing, revision, and chunk ordinal. The exact hash construction is an application decision, but the properties are not: no collision across tenants, no reuse across revisions, and reproducibility during reconciliation. Random IDs can work only if the ledger is never bypassed. Smaller chunks improve targeting but multiply deletion work and audit volume. Suppose 10,000 listings average eight chunks. That is 80,000 vector IDs, not 10,000, and it is also 80,000 potential cardinality values if IDs become telemetry labels. Keep document IDs in records or structured event bodies, never metric labels. A counter labeled by result and operation stays bounded; a counter labeled by document ID grows with the corpus. Bytes accumulate. Retention math matters too. If one compact audit row averages 300 bytes, one million rows begin around 300 MB before indexes, replication, and storage overhead. The point is not that 300 bytes is universal; it is that retention should be calculated from observed row width and request volume. Measure both. Retaining raw query text, vector payloads, or listing descriptions would expand the bill and weaken the erasure story at the same time. Freshness introduces a second clock. The source connector may have fetched revision 42 while revision 41 is still searchable. The ledger must represent both until 41 is removed, and account erasure must select both. Pause scheduled crawls first, then drain or invalidate queued writes. This is why a metadata-only delete is insufficient as the sole control: the application still needs to know which revisions existed and whether each write reached its terminal state. How the deletion controls differ across real options The important comparison is not syntax. It is which system owns enumeration, how narrowly deletion can be selected, and what evidence the application can retain without copying the erased content. | Option | Deletion control | Practical boundary for this workflow | |---|---|---| | Pinecone | Deletes records by explicit IDs or a metadata filter | ID deletion aligns with an application ledger; a filter still depends on complete tenant metadata and should be verified afterward. | | Qdrant | Deletes points using point IDs or a filter selector | Its selector model is useful when payload metadata is governed, while ledger-backed IDs remain the stronger cross-system evidence. | | Weaviate | Deletes objects by ID and supports filtered batch deletion | Batch filters can reduce calls, but an independent ID inventory is still needed to prove scope and support migration. | | PostgreSQL with pgvector | Uses normal relational deletion and transactions around vector-bearing rows | Ownership and vectors can share one transactional database, at the cost of operating query performance and index maintenance there. | | Infrai | Exposes vector deletion and query through REST | It suits teams standardizing backend calls behind one bearer key; the application must supply IDs and perform the verification query. | Pinecone, Qdrant, and Weaviate all offer useful metadata-oriented controls, but none removes the need to govern metadata at ingestion. PostgreSQL with pgvector changes the architecture more substantially: referential constraints and transactions become available in the same data model, while specialized vector-service operations no longer belong to a managed vector control plane. There is no universal winner. Choose based on the failure you need to make impossible. If inconsistent tenant metadata is the main risk, explicit IDs from a relational ledger are portable across all five options. If transactional coupling between ownership rows and vector rows dominates, pgvector deserves serious consideration. If the team wants a service API and does not want another Node.js SDK lifecycle, a REST surface is attractive, provided schema discovery and contract tests remain part of deployment. There are clear limitations. Infrai is not a fit when the deletion must commit atomically with relational account rows; PostgreSQL with pgvector is the stronger option for that requirement. It is also a poor choice if organizational policy requires direct operation of the vector engine or a vendor-specific control that is absent from the verified REST surface. Conversely, a team already standardized on Pinecone, Qdrant, or Weaviate gains little by moving this narrow workflow merely to avoid an SDK. The ledger-and-verification pattern is more important than the provider. Roll out without losing the evidence Start by backfilling the ledger from the ingestion records, not by attempting to infer ownership from nearest-neighbor results. Reconcile its count against every active revision, then put new writes behind the ledger transaction. Only after that should the account-deletion handler use it as authority. Run the handler in report-only mode on synthetic tenants first. The report should contain the expected ID count, deleted count, verification outcome, and timestamps, with no source text. Next, enable deletion for a narrow cohort and monitor bounded metrics such as requests by result, retry count, and verification failures. Do not label metrics with customer or document IDs. Set retention independently for operational logs, audit rows, and request metadata. Operational logs may need days; audit evidence may need longer under the organization's policy. Neither duration can be derived from vector retention alone. Once reconciliation is stable, remove the old deletion path so two implementations cannot disagree about what “all customer data” means. The final acceptance test is deliberately plain: close the account, search using removed listing language, and receive no removed document. A deletion receipt without that test is an activity record, not proof of outcome. No shortcut changes that. References - Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks - Pinecone: Delete records - Qdrant: Delete points - Weaviate: Delete objects - pgvector

  14. X@_Mira___Mira_ · 22 likes · 2 reposts · 874 views

    We have a candidate proof for the first of the Sude Conjectures eventually being true. So checking finitely many cases would prove it. github.com/Mira-Cult/math/tree/main/notes/sudes-f… The proof is nonconstructive, so no explicit bound is known. Astra thinks quasi-Riemann might get us a number.

  15. Redditu/profazia_ · r/alphaandbetausers · 1 point · 2 comments

    Looking for 5 developers to test an AI app builder (free access) I'm building Exova. You describe an app, a team of AI agents builds it, and then a reviewer agent actually runs it and tests it before handing it to you. On a public benchmark it beat Claude Code (Opus 5.5), 147 to 146, at about a fifth of the cost: getexova/coffer-bench I'm looking for 5 developers to try it free this week. Build one small thing (under an hour) and tell me what broke. Request access: tryexova.com

  16. Redditu/Affectionate-Bit5072 · r/ClaudeCode · 1 comment

    I built a terminal app that keeps Claude Code as your main agent and brings in Codex or a local model when you want a second opinion Hey all. I've been working on this for a few weeks and just shipped 0.2.2. What it is Argonauts Code is a terminal app that looks and handles like Claude Code that inline chat, Shift+Tab for approval modes, /model. You pick the agent you talk to like Claude Code, Codex, agy, or OpenCode, which can run a local model. If you pick Claude Code and keep the recommended setup, it does the work in your folder the same as running claude yourself, until you ask for more. The app starts Claude Code's own program and reads its stream-json output, so your sign-in, MCP servers, skills and plugins stay as they are, and it never reads your tokens. The part I actually wanted was this: when I say "have Codex review it", the change moves to its own worktree, Codex reads it and sends it back until it passes, and it only lands when I approve it or a rule I set does. For bigger jobs there are team workflows where a planner splits the work and several agents build in parallel worktrees. How Claude Code was used For most of the code, honestly. I ran Claude Code (mostly Opus) as a bunch of agents: builders in parallel lanes, each in its own worktree, then separate reviewer agents that wrote up issues and fixer agents that worked through them. My job was the design and the calls. Every screen started as a text drawing I approved, and a screen only counts as done when the real app matches its drawing cell for cell. Decisions went into a numbered log so the agents had something to check against, and every change goes through a PR with CI. What I learned 0.2.0 shipped with screen bugs while about 9,900 tests passed. The tests drew the Behaviors list in a 60-row window and never tried the Limits panel wider than 140 columns, so what I saw in a normal terminal wasn't what the tests saw. Now the release build gets checked at 120×38 and 177×40 against the approved drawings. The number of tests turned out to matter a lot less than whether they looked at what I look at. Good to know - Free and open source (Apache-2.0). No paid tier, nothing hosted, not affiliated with Anthropic. - Alpha, macOS and Linux only. - 10k+ tests and none of them call a model. Each CLI's output is recorded once and replayed. - The video is a scripted tour with stand-in agents and sample data. The run window, the galaxy view in Behaviors and the mascot that shows up when a session starts are next version, not 0.2.2. Repo: sheng-tse/argonauts-code brew install sheng-tse/tap/argonauts-code or npm install -g argonauts-code, then argonauts doctor shows which CLIs it finds. npx argonauts-code tries it without installing. Happy to answer questions, especially about plan usage or how it drives Claude Code.

  17. X@herenfor · 16 views

    阅读器已经来到0.3.11版本,简单的优化了一下控件,操作逻辑,还有小型的动画改进。忘记说了也支持英文ui(我是不是应该用英文写一版🤔) 好用的话希望推荐给周围的亲朋好友使用。有什么想法也可以提哦。下个版本大概就是把漫画格式支持一下,也许还会有txt格式的强兼。 herenfor/epub-read

  18. Styling Server Components without a stylesheet or a build step --- title: "Styling Server Components without a stylesheet or a build step" published: true description: "Style React Server Components with typed props and no 'use client', style registry or build plugin, with the CSS inside the HTML React streams." tags: react, nextjs, css, webdev canonical_url: box-kite.dev cover_image: box-kite.dev series: Building with Box Kite --- Style React Server Components with typed props and no 'use client', style registry or build plugin, with the CSS inside the HTML React streams. This article shows how that works in a Next.js App Router app, measures what it costs against a plain CSS module, and lists what still has to run on the client. _The examples here are screenshots; they run live in the original article._ The problem You moved a page to the App Router, and the first component that styles itself wants 'use client'. Runtime CSS-in-JS works by collecting styles while the tree renders and then writing them somewhere, either from an effect or through a context that a provider sets up. A Server Component has neither. It runs once, on the server, and React never calls an effect there. The Next.js guide to CSS-in-JS lists the popular libraries as supported in Client Components. The recipe takes three pieces: a style registry, a useServerInsertedHTML callback that flushes what the registry collected, and a 'use client' wrapper around the app. Where Server Component support has been added since, the theme provider is the part that had to go, because context does not exist on the server. The usual ways around it each cost something real: - Put 'use client' on everything that styles itself. The build passes. But every component with a style now ships its code to the browser and hydrates, which is the cost Server Components exist to remove. - Move to a compiler that extracts CSS at build time. It ships no runtime, but it adds a bundler plugin, and a value only known at render time has to become a CSS variable written by hand. - Go back to stylesheets. This is reliable, but the styles live in one file and the markup in another again, and nothing checks that a class name you wrote still exists. Styling as rendering Box Kite takes a different route. Every CSS property is a typed prop, and in a Server Component it does not inject anything. Each rule a Box needs comes back as a React element, <style href precedence>, rendered next to the markup. React 19 hoists those elements into <head>, keeps one copy per href, and orders them by precedence. Styling becomes part of rendering, so it needs no effect, no provider and no registry. Here is a Server Component page. There is no 'use client' in it and nothing above it: import Flex from '@box-kite/react/components/flex'; import Grid from '@box-kite/react/components/grid'; import { H1, H2, P, Span } from '@box-kite/react/components/semantics'; const orders = [ { id: 4100, customer: 'Ana', status: 'Shipped' }, { id: 4101, customer: 'Ion', status: 'Packing' }, { id: 4102, customer: 'Mara', status: 'Delivered' }, ]; export default function OrdersPage() { return ( <Flex d="column" gap={6} p={6} maxWidth={300} mx="auto"> <H1 fontSize={28} fontWeight={700}> Orders </H1> <Grid gridTemplateColumns={1} gap={4} md={{ gridTemplateColumns: 3 }}> {orders.map((order) => ( <Flex key={order.id} d="column" gap={2} p={5} borderRadius={3} b={1} borderColor="slate-200" bgColor="white" hover={{ borderColor: 'sky-500' }} theme={{ dark: { bgColor: 'slate-900', borderColor: 'slate-800' } }} > <H2 fontSize={16} fontWeight={600}> Order #{order.id} </H2> <P fontSize={14} color="slate-600" theme={{ dark: { color: 'slate-400' } }}> {order.customer} </P> <Span fontSize={12} fontWeight={600} color="sky-600"> {order.status} </Span> </Flex> ))} </Grid> </Flex> ); } !The orders page: a heading and three order cards, the middle one under the pointer. The page has a breakpoint, a hover state and a dark theme. Each is just one more rule, so all three render on the server like the rest. You don't configure anything for this. The package's react-server export condition gives a Server Component a build of Box that calls no hook and never touches the DOM. Importing it is the whole setup. Look at the HTML response and you'll find two <style> elements in <head>. React merges each precedence group into one element and lists what it merged in data-href. Every class in the markup has its rule in that response, so nothing waits for JavaScript to define it. The class names are hashes of their content, which is why the class the server wrote is exactly the class a client bundle would compute. Hydration has nothing to disagree about. The order of the rules is not left to chance either. React hoists elements in the order it meets them, and rules are shared between Boxes, so element order alone could let p override px. Every rule therefore sits in a cascade layer, and the first style element declares the order of all layers once. Layer order beats source order. What it costs, measured Talk of "zero runtime" is cheap, so here are numbers instead. The setup: - a Next.js 16.3.5 production build (next start) with React 19.3, measured on a laptop; - a page of cards like the one above, each a Flex with an H2, a P and a Span inside, so four Boxes per card; - a baseline page with the same markup, styled by a plain CSS module. Both pages render on every request. | Cards | HTML, gzipped (Box / CSS module) | Server response, median of 40 (Box / CSS module) | | ----- | -------------------------------- | ------------------------------------------------- | | 100 | 11.2 KB / 4.4 KB | 15 ms / 10 ms | | 1,000 | 33.6 KB / 24.7 KB | 79 ms / 35 ms | The JavaScript the browser downloaded was byte for byte the same on both pages: Next.js's own runtime, 172.9 KB gzipped. None of those chunks contained the styling engine. On a page with no client component, the engine never leaves the server. Two costs show in the table, and both are real: - Rendering a Box takes time. At 1,000 cards, the page with 4,000 Boxes took 44 ms longer to render than the one with plain class names, which is about 11 µs per Box. Boxes styled alike resolve through one cache lookup, so a long list of identical rows costs less than a page of all-different elements. - The CSS travels in the HTML. A CSS module is a file the browser caches once for the whole site, while these rules come with each response. Most of the gap at 100 cards is the base stylesheet: the reset and the layer order, about 24 KB before compression, sent with every page. What measuring this turned up The first run of this benchmark didn't look like the table above. The page with 1,000 cards weighed 102 MB. On screen everything was right: two style elements in <head>, every class styled. The extra weight was in the RSC payload, the copy of the component tree that Next.js puts under the HTML for the client to pick up. React removes duplicate style elements from the page, but the payload carried every Box's elements in full, including the 24 KB base stylesheet, once per Box. The fix is in the library: every Box now gets the same element objects. React's serializer sends an object it has already sent as a short reference, so the base stylesheet now crosses the wire once. That turned 102 MB into the 1.3 MB of the table above, and it shipped in Box Kite 2.2.4. A regression check now measures it against a real Next.js build on every pull request, because no unit test could have seen it. Suspense streams the CSS with the markup Streaming is where collecting styles in a registry gets awkward. The registry flushes when the shell is ready, and a section that arrives later needs its own flush. Here the CSS is part of what a component renders, so it arrives in the same chunk as the markup it styles: import Flex from '@box-kite/react/components/flex'; import { H2, P } from '@box-kite/react/components/semantics'; import { Suspense } from 'react'; async function fetchTotals() { await new Promise((resolve) => setTimeout(resolve, 700)); return { revenue: '€48,200', orders: 1204 }; } async function Totals() { const totals = await fetchTotals(); return ( <Flex d="column" gap={1} p={6} borderRadius={3} b={1} borderColor="emerald-500"> <H2 fontSize={18} fontWeight={600}> {totals.revenue} </H2> <P fontSize={14} color="slate-600"> from {totals.orders} orders this month </P> </Flex> ); } export default function Dashboard() { return ( <Suspense fallback={<P color="slate-500">Loading totals…</P>}> <Totals /> </Suspense> ); } The example app in the repository has a section like this behind a 700 ms wait. Its smoke test checks the served HTML: the fallback, the late markup and the late section's own rule are all in the response. A style element that arrives after the shell is streamed disabled (media="not all"), and React turns it on when it reveals the boundary, so the late section never shows unstyled. Themes without a provider A provider can't run on the server, but a theme doesn't need one. In Box Kite a theme rule is scoped to an ancestor carrying the theme's class. The server decides the theme by putting that class on <html>: import type { ReactNode } from 'react'; export default function RootLayout({ children }: { children: ReactNode }) { return ( <html lang="en" className="dark" data-theme="dark"> <body>{children}</body> </html> ); } Every theme={{ dark: … }} below it applies from the first paint. Switching later means changing that one class in the browser, which re-renders nothing. Dark mode without the flash covers the rest: the reader's own preference, a stored choice, and the few lines that run before the first paint. Client components: one line, once Most apps still have interactive parts. A client component resolves the client build of Box, which by default writes its rules through the CSSOM after hydration. That works, but it means the server-rendered HTML of an island would arrive without its CSS. One module puts the island on the same path as the server: 'use client'; import Box from '@box-kite/react'; Box.configure({ sink: 'element' }); Import it from your client components, and an island's rules are in the HTML before it hydrates, under the same class names the server used. The ready-made components split the same way. Flex, Grid, Button, Textbox, the headings and the other semantic elements, the SVG elements and Icon call no hook, so a Server Component renders them with their CSS. Those that hold state, such as Dialog, Menu, Tabs or DataGrid, ship with a 'use client' banner. Importing one into a Server Component opens a client boundary rather than failing the build. The honest limits - It is runtime CSS-in-JS on the server. About 11 µs per Box in the measurement above. That's small next to a database call, but it isn't zero, and a page of thousands of different elements will notice. - The CSS isn't a cached file. It travels with every HTML response: about 9 KB more than a CSS module at 1,000 cards, gzipped, and the base stylesheet on every page. - React 19 only. Hoisting <style href precedence> arrived in React 19. On React 18, keep the default mode, which writes to a stylesheet from the client. - Box.Theme and hover-callback children stay on the client. They need state. The theme rules work on the server, as shown above. - Your own CSS wins. Every Box rule sits in a cascade layer, so an unlayered stylesheet of yours overrides it. That's usually what you want, but it surprises people who expect props to win. Try it - React Server Components is the reference for this mode, including server rendering without Server Components. - examples/next-app in the repository is the App Router app the checks above run against: a streamed section, a client island, a theme toggle and a page of the ready-made components. - npm install @box-kite/react, then import Flex into a page that has no 'use client'. --- _Originally published on box-kite.dev._ Box Kite is open source under MIT — if it is useful to you, a star on GitHub helps other people find it. Install it with npm install @box-kite/react.

  19. X@rickbrewPDN · 9 views

    @ComradeEepster @spagkitty @sast3rs4 you can try this -- still in rough shape but making good progress paintdotnet/Paint.NET-on-Wine

  20. X@imdevman · 11 views

    맥북에서 은행 웹사이트 쓰는 사람들을 위한 구제 레포 Oct7/touchen-camera-fix

  21. Redditu/AdWorldly824 · r/QuantifiedSelf · 4 points · 26 comments

    Building a personal data platform, possibly reusing existing project like aurboda Hi folks, I've been thinking about what a "personal data platform" would look like, for 2026 and beyond. With the help of AI, i've been iterating on desired scope and characteristics and also have been analyzing and comparing lots of interesting projects to see if there's something existing already which is close enough for all the details on goals and research, see Dieterbe/personal-health-data-platform ; but the TLDR is basically i think the ideal personal data platform : - would hold blood test lab results, nutrition/calorie logs, gym logs, sleep, activities, etc - has a self-hosted database, as well as an web API, an MCP endpoint, as well as an ability to integrate with local-first mobile apps (allow data sync for offline use with conflict resolution) - i imagine different mobile apps (e.g. habit tracker, gym tracker, food logger, etc) could all have an local-first experience, but pull from, and sync to, this central platform with some kind of sync policy support about which data each app can see, and write to. (something like powersync is really interesting here, as the mobile apps would work with a local sqlite, but it syncs to/from the server automatically, and you can define policies on the server to, for example, only send fitness and nutrition data to your gym app, and not your blood lab tests) - treats UI as optional. UI's can always be built on top later, and personal agents can answer questions directly if they have access to the data. - catalog first: this idea might be a contentious, i'm not sure, but for example for gym exercises, i think logging exercises with whatever names the user likes, is a good first step, but ultimately you'd want to rename or map them to using "recognized", or "official" exercise names. If the platform has its own catalog of known exercises with specific identifiers, then it unlocks various things (knowing the effects of the exercise on muscles worked, suggesting alternative exercises, etc - as a personal trainer i know that various formulas around 1RM/VBT/RIR/calorie expenditure etc are exercise specific, and muscle recruitment is even sensitive to variations of the same exercise - i have experimented with building a catalog in body.build though it's probably too in-depth for most users). So I envision a system with known, versioned catalogs, while allowing users to submit free-form records into the system, but encourage them to transition or map them to "first-class" records. After looking into >30 existing projects (see github.com/Dieterbe/personal-health-data-platform…), one of the more interesting ones is fiddur/aurboda ; it looks comprehensive already and philosophically aligned. I'm not sure how this subreddit works exactly, it's my first time posting here; but I'm curious for any input, and wanted to tag u/fiddur specifically as he created aurboda and seems to be on the same page regarding the catalogs; i'm also really curious what he thinks about the offline-sync idea. FWIW I have previously contributed to other projects, such as body.build (open source gym tracking app with exercise catalog) and wger.de (gym/nutrition tracking app, where i worked primarily on nutrition and powersync support)

  22. Location: Bengaluru, India Remote: Yes Willing to relocate: Yes, with visa sponsorship Technologies: JavaScript, TypeScript, Rust, React, Next.js, Vue, Angular, harness development for open models Résumé/CV: resume.shantaram.xyz Email: me@shantaram.xyz GitHub: github.com/xyzshantaram

  23. Redditu/sachit324 · r/IMadeThis · 1 point · sachit1751-art/Audify

    [DEV] Audify — A free, open-source Android music player Title: [DEV] Audify — A free, open-source Android music player Hey everyone, I'm the developer of Audify, an Android music player I've been building. It's free, open source (GPL-3.0), and has no advertisements or in-app purchases. Some features include: - Local music playback and playlist management - Lossless audio support - Synced lyrics - Music discovery - Crossfade and Automix I'd appreciate feedback from people who care about privacy-friendly, open-source Android apps. I'm happy to answer questions about the project.

  24. X@serhiyhvala · 1 like · 11 views

    @LukeberryPi ahhh got it, you're on the release build, that's exactly the bug I fixed. Cursor % (and cost/tokens) show up with my PR: t3code#29419 hope Theo takes a look 🤞

  25. New Nintendo Switch 2 Exploit Uses Civilization VII Switch 1 Edition As An Entry Point A new exploit for the Nintendo Switch 2 uses the Switch 1 edition of Sid Meier's Civilization VII as an entry point. The toolchain, dubbed CivSwitch, was developed by hacker Gezine and uses a cross-site…

  26. X@clxymox · 3 views

    Le compromis : le code reste brut et exige des ajustements manuels de batch pour éviter l'OOM sous 80 Go de VRAM. Une base hackable redoutablement efficace. 🔗 karpathy/nanochat

  27. Bluesky@juanlu.space · 1 like

    I clicked hoping to find some real organizing, but according to GitHub stats it's basically 1 guy + his Claude subscription? 🫩 "The moat is ops", and also showing up every day for months and years after the first day of rage-coding github.com/occupysaas/salescompel/graphs/contribu…

  28. DEV@maxpro · 3 comments

    Dark mode without the flash --- title: "Dark mode without the flash" published: true description: "A dark mode should paint the reader's theme on the first frame, switch without re-rendering the page, and let one section disagree with the rest." tags: react, css, darkmode, webdev canonical_url: box-kite.dev cover_image: box-kite.dev series: Building with Box Kite --- A dark mode should paint the reader's theme on the first frame, switch without re-rendering the page, and let one section disagree with the rest. Most manage one or two of those three jobs. This article builds all three with Box Kite, shows what each line costs, and is explicit about the one piece the library leaves to you. _The examples here are screenshots; they run live in the original article._ The problem Somebody opens your server-rendered page at night with their system set to dark. The HTML arrives, the browser paints it — white — and a moment later JavaScript runs, reads the preference and repaints everything dark. That flash is the most-reported dark-mode bug there is: the long-running Next.js discussion on it has dozens of replies, and a newer one opened because the usual fixes broke in the App Router. The fixes people reach for each trade one problem for another: - Keep the theme in React state and pass it to every component. The server cannot know the reader's preference, so it renders a guess; the client renders the truth; React reports a hydration mismatch and the page flashes anyway. Every switch re-renders the tree. - Two sets of CSS variables, swapped by a class. This is the right mechanism, but it means a stylesheet of tokens maintained apart from the components that use them, and every new colour is an edit in two places. - Hide the page until JavaScript has decided. No flash, and no content either, for as long as the bundle takes. The model: a theme is a class on an ancestor In Box Kite a theme is a prop on the element it styles: import Box from '@box-kite/react'; export function Card() { return ( <Box p={6} borderRadius={3} b={1} bgColor="white" color="slate-900" borderColor="slate-200" theme={{ dark: { bgColor: 'slate-900', color: 'slate-100', borderColor: 'slate-800' } }} > The light colours are plain props, the dark ones are in theme. </Box> ); } !The same card twice: under a light ancestor and under a dark one. The library turns theme={{ dark: … }} into an ordinary CSS rule that applies when an ancestor carries the class dark. Nothing about it happens in React: there is no context to read and no prop to thread through. Which theme is showing is decided by one class on one element — usually <html> — and everything below follows it. That one decision is what makes the other three jobs cheap. Deciding the theme: Box.Theme Box.Theme is the part that decides. Put it around the app once: import Box from '@box-kite/react'; import { StrictMode } from 'react'; import { createRoot } from 'react-dom/client'; import App from './App'; createRoot(document.getElementById('root')!).render( <StrictMode> <Box.Theme use="global" storageKey="theme"> <App /> </Box.Theme> </StrictMode>, ); use="global" writes the theme onto <html>. With no choice stored, it follows prefers-color-scheme — and keeps following it, so a system that switches to dark at sunset takes the page with it. storageKey persists an explicit choice in localStorage, and a stored choice wins over the system from then on. A switch is a hook: import Box from '@box-kite/react'; import Button from '@box-kite/react/components/button'; export function ThemeSwitch() { const [theme, setTheme] = Box.Theme.useTheme(); return ( <Button onClick={() => setTheme(theme === 'dark' ? 'light' : 'dark')} props={{ 'aria-label': 'Switch theme' }}> {theme === 'dark' ? 'Light' : 'Dark'} </Button> ); } setTheme(null) forgets the stored choice and hands control back to the system. What a switch costs. We measured it in Chrome with a render counter on every component: pressing the switch changed one class on <html>; the component that called useTheme() re-rendered, because it reads the theme; the page component, whose every colour changed, rendered exactly once in total — on mount. The colours change because the browser re-matches CSS, not because React re-rendered anything. The first frame: a few lines you own Box.Theme reads the system preference and the stored choice in the browser, after React starts. In a single-page app that is before anything is painted, so there is nothing to flash. A server-rendered or prerendered page is different: the HTML paints before any JavaScript runs, so the theme class has to be on <html> before that first paint — and only a script in the <head> runs early enough. The library does not inject one for you; it is yours, and it is short. Ship the light theme in the HTML, and swap it before the body is painted: <html lang="en" class="light" data-theme="light"> <head> <script> try { var theme = localStorage.getItem('theme') || (matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'); var root = document.documentElement; root.classList.remove('light', 'dark'); root.classList.add(theme); root.setAttribute('data-theme', theme); } catch (error) {} </script> </head> </html> The key is the same storageKey the provider uses, and the rule is the same — stored choice first, system second — so when React starts, Box.Theme resolves the theme the script already chose and leaves <html> alone. We checked that too: with the system set to dark, the class on <html> changed exactly once, from the shipped light to dark, before React ran, and never again; with light stored, the same page under a dark system kept light throughout. The try is for the reader whose browser blocks storage — they get the light theme the HTML shipped, which is also what a reader with JavaScript turned off sees. Two variations: - If your server already knows the choice — from a cookie, say — render the class on <html> on the server and skip the script. The repository's Next.js example renders <html className="dark" data-theme="dark"> in a Server Component, and the theme needs no provider at all there, because the rules only care about the class. - If React renders the <html> element (Next.js and other frameworks do), the script changes an attribute React also rendered, so add suppressHydrationWarning to that element — the warning is about exactly the change you meant to make. This is how box-kite.dev itself works: every page is prerendered in the light theme, and an inline script in the shell switches it before the first paint. A section that stays light Real pages have parts that ignore the page's theme: a code sample that is always dark, a print preview that is always light, a marketing block with its own colours. Because a theme is a class on an ancestor, a nested Box.Theme is simply a nearer ancestor: import Box from '@box-kite/react'; export function PrintPreview() { return ( <Box.Theme use="local" theme="light"> <Box p={6} bgColor="white" color="slate-900" theme={{ dark: { bgColor: 'slate-900', color: 'slate-100' } }}> Light, whatever the page around it is doing. </Box> </Box.Theme> ); } !The theme switch, the card, and the print preview. With the page dark, the card follows it and the preview stays light. The nested theme is a real boundary, not a second class competing with the first. Each theme rule is written with CSS @scope, from the theme's class down to the next element that declares a theme of its own, so the dark page's rules stop at the light section's edge — including for a property the inner section never mentions. In the measurement above, the light section kept its light background while the page around it was dark, and kept it through every switch. The switch, animated A theme change can cross-fade the whole page instead of snapping: import Box from '@box-kite/react'; import type { ReactNode } from 'react'; export function Root({ children }: { children: ReactNode }) { return ( <Box.Theme use="global" storageKey="theme" viewTransition> {children} </Box.Theme> ); } viewTransition runs the switch inside the browser's View Transitions API. Writing it by hand has a trap — the browser captures the page the moment your callback returns, before React has rendered the new state, so a hand-rolled version captures the old theme twice and nothing appears to animate — and the prop flushes the update inside the callback for you. A reader who asked for reduced motion gets the theme change without the cross-fade, and a browser without view transitions simply switches. Charts follow too The theme reaches markup the library did not render, through CSS variables. A chart library takes a colour string; give it a variable, and declare the variable per theme on a container: import { ChartContainer } from '@box-kite/react/components/chart'; import { Line, LineChart, ResponsiveContainer } from 'recharts'; const months = [ { month: 'Jan', revenue: 12 }, { month: 'Feb', revenue: 18 }, { month: 'Mar', revenue: 15 }, ]; export function Revenue() { return ( <ChartContainer series={['revenue']} height={60}> <ResponsiveContainer width="100%" height="100%"> <LineChart data={months}> <Line dataKey="revenue" stroke="var(--color-revenue)" strokeWidth={2} dot={false} /> </LineChart> </ResponsiveContainer> </ChartContainer> ); } !The revenue line, in the colour the container declares for the page's theme. ChartContainer declares one --color-<series> per name, with a value for each theme, so the chart names no colour at all and its dark mode is the page's. The charts page shows a full example with a grid and axis labels. The honest limits - The pre-paint script is yours. For a server-rendered page, nothing in the library can run before the first paint; the few lines above are the whole of it, and they have to agree with the storageKey you gave Box.Theme. - Theme rules need @scope: Chrome 118, Safari 17.4, Firefox 128 and later. In an older browser the theme rules are dropped — which is why the examples here write the light colours as plain props and only the dark ones in theme: an old browser then shows a working light page rather than an unstyled one. - The system preference only knows light and dark. A theme is any class name — high-contrast, sepia, a brand theme — and theme={{ 'high-contrast': … }} works the same way, but choosing one of those is always an explicit setTheme. Try it - Theme setup — the reference for theme, Box.Theme and component themes. - The playground — write a theme prop and see the rule it produces. - npm install @box-kite/react, and wrap your app in Box.Theme. --- _Originally published on box-kite.dev._ Box Kite is open source under MIT — if it is useful to you, a star on GitHub helps other people find it. Install it with npm install @box-kite/react.

  29. X@alexzfunk · 20 likes · 772 views

    The whole thing is free MIT license and you can add and improve upon it however you please. SparkHome: a-funk/sparkhome

  30. X@polytutor · 14 views

    Revisited 14/39: Cross-Venue Arbitrage. Pair related Polymarket and Kalshi contracts so total cost sits under the minimum payout. Test: log how often both legs fill at quote. Main failure: the contracts aren't truly equivalent. Not advice. github.com/Polytutor-AI-Labs/polymarket-strategy-… t.co

  31. YouTubebomba y sus cacharros · YouTube description · 376 likes · 87 comments · 17,118 views

    interfaz de audio Firewire a USB con fuegocable, un modchip open source fuegocable.org github.com/fuegocable reddit.com fuegocable es un proyecto de código abierto que apunta a dar una nueva vida a las interfaces de audio FireWire. El proyecto tiene como objetivo proporcionar documentación, herramientas, así como recursos de hardware y software, para modificar estas interfaces y añadirles conectividad USB. Esto permite utilizarlas con computadoras modernas y otros dispositivos compatibles con el estándar USB Audio Class, incluyendo sistemas como Windows, macOS, Linux, Android, iOS y cualquier otra plataforma que ofrezca la compatibilidad necesaria con USB Audio Class. La Presonus Firestudio Project es la primera (y por ahora única) interfaz modificada para funcionar con USB. [en] Firewire audio interface to USB mod with fuegocable, an opensource modchip fuegocable.org github.com/fuegocable reddit.com fuegocable is an open-source project aimed at giving new life to FireWire audio interfaces. The project aims to provide documentation, tools, and hardware and software resources for modifying these interfaces to add USB connectivity, allowing them to be used with modern computers and other USB Audio Class-compatible hosts, including Windows, macOS, Linux, Android, iOS, and other platforms that provide appropriate USB Audio Class support. The PreSonus FireStudio Project is the first (and, for now, the only) interface to be modified to function via USB.

  32. It’s 0.0.1, so here is what’s missing: page history and rollback, search inside pages, and the buttons readers press to report an issue or bookmark a page. AI for docs is planned, with no date. Try it, star it, or back us with a founding seat 💜 mishka-group/mishka_document

  33. X@mmastrac · 21 likes · 4 reposts · 1,371 views

    We've really been pushing on multi-model support on gr8! Four DGX sparks, with three models to choose from. Each model is accelerated with EXLR8 - faster decode and lightning fast boot (< 30s!) kindlingai/gr8 t.co

  34. @samrbalagot I've made something like this, not at this level but upto some extent It's available here: pratyush06-aec/callmi_2.0 Would like to get your thoughts on this !

  35. X@thymikee · 9 likes · 1 repost · 566 views

    later in November we'll make agent-device leaner and move some of the functionality, such as remote providers, to plugins. I guess every project will have its inflation and shrinking phase and we're approaching that now that core functionality is locked github.com/callstack/agent-device/milestone/1 t.co

  36. Location: Birmingham, AL Remote: Yes Willing to relocate: No Technologies: TypeScript, Python, React, Next.js, React Native, Node.js, FastAPI, LangChain, PostgreSQL, Docker, AWS/GCP Résumé/CV: linkedin.com · github.com/bmanturner Email: hnjobs@foglet.io Lead full-stack engineer with 11 years of experience, looking for Senior or Tech Lead roles. Since 2023 I've shipped LLM products: the natural-language-to-SQL API behind HEAVY.AI's HeavyIQ, and weekly search-analytics agents for 1,000+ clients at Copysmith, where I owned the architecture. I built the UI/UX for HeavyRF, an NVIDIA Omniverse digital twin shown in the GTC 2022 keynote, and spent six years on HIPAA-regulated healthcare apps. I also run Flippd (flippd.gg), a pinball app with 1,600 monthly users.

  37. X@iameythakur · 1 like · 15 views

    Every optimisation is a claim that two things are the same. A cache says a checked term is still fine. Sharing says two pointers mean one value. Wrong, most software gets slow. A proof checker accepts a false proof, quickly. Amey-Thakur/SAIR-LEAN-KERNEL-CHALLENGE

  38. X@AlexChhk · 18 views

    @raulizahi @Tech_girl @socra_ai nice, memory notes + tests + code comments is a solid handoff. i built concord for the same gap, agents post handoffs/claims and shared decisions land in a local sqlite so codex picks up without you narrating. open source: Get-Concord-AI/concord-mcp

  39. @artistxeature Just pushed an experimental Linux CLI worker + ComfyUI adapter. Mac access via SSH. github.com/RockHammer1947/IdleDock/blob/main/docs… I don’t own a Spark, so no real DGX/CUDA testing yet. Please try it and share feedback/issues. PRs welcome—let’s build it together!

  40. X@ybsgige · 2 likes · 78 views

    Made naru so agents stop forgetting stuff between sessions. they write down what they learn, I approve it (or make a clanker do it), every session already knows. Survives compaction and is extremely context efficient j2bap/naru t.co

  41. Redditu/lexesm · r/webos · 16 points · 9 comments

    StremCompat 3.0 update: Homebrew Channel install, one-press best source and smaller changes based on community feedback (full changelog on GitHub) StremCompat is a free, open source client for LG TVs that have no official Stremio app. Might work in webOS 5.0+. Version 3.0 is out (currently 3.0.5). What's new: - Homebrew Channel: install and update from our own repository, and the app tells you when a new version is out - Much smaller: about 6 MB to download instead of 46 MB, and lighter on memory - Best source: one press asks for the quality and goes straight to the film - More languages: English, Brazilian Portuguese, Spanish, French, German, Italian and Russian - New torrent engine, which no longer depends on Stremio's server or a bundled Node.js - New look (minor changes): cleaner Home and title pages, round action buttons, larger and brighter small text - Backup languages for audio and subtitles, and the chosen subtitle is remembered - Clearer source list, with one-line file names and codecs shown only as compatibility warnings - Fixes for long pauses, slow torrents and sources or subtitles that fail Install without a pc if your TV already have Homebrew: Full HD and 4K screens: alexesmm.github.io Smaller screens (720p): alexesmm.github.io Otherwise, the install guide and the compatibility list are on GitHub: Alexesmm/stremcompat-lg-webos There is also a test version for Samsung models. Unofficial and not affiliated with Stremio or LG. Reports from other TV models are very welcome. There's also another interesting and promising project for these TVs, stremio-origin, worth trying to see what works best for you.

  42. Redditu/Lakster37 · r/SierraLeone · 23 points · 1 comment

    Sierra Leone Map with New Districts (Unofficial) As many of you probably heard, Sierra Leone is adding two new districts (for a total of 18) in the southeast of the country: Bandajuma District and Kpanguima District (also spelled Kpanguma and Panguma). Even though it's been announced for awhile and was made official in October, I have found very little information about which Chiefdoms these new Districts will actually include and I don't think any official maps have been publicly released yet. Based on the information I could find online, this is roughly what the new (and old) Districts will look like. The second image shows the previous boundaries of the old 16 Districts for comparison. Please note that this is based on unofficial sources, so it may be different from the final, official release, but I think they are close enough to get a general idea. The third image shows a more zoomed in view with the names of the relevant Chiefdoms and old District boundaries in gray. How I Sourced These Maps Map data is often packaged as a "GeoJSON" file, and I noticed recently while doing some research of Sierra Leone geography (for a Geography game I'm making) that it's very difficult to find updated GeoJSON files even for the 16 Districts that were established in 2017/2018 - almost all were still of the older 14 Districts (excluding Falaba and Karene Districts). The only data I could easily find with 16 Districts was from the Humanitarian Data Exchange, but even this wasn't completely accurate because it still had the older Chiefdom boundaries, and some of the new Chiefdoms also made in 2017 (made from splitting an old Chiefdom in two) had part of a Chiefdom split into one District and part split into a different District (for instance, without splitting the old Gbanti Kamaranka Chiefdom into two new Chiefdoms [Gbanti Chiefdom and Kamaranka Chiefdom], it would actually separate Karene District into two disconnected parts, separated at the narrowest region). I made any needed Chiefdom splits using the included Section data and looking at other maps online to see which Sections went to each split Chiefdom. The website citypopulation.de was what I primarily used, since it has the most accurate and detailed publicly available Salone map I've been able to find. It's a little flawed because there seem to be some small discrepancies/changes in the Section borders themselves (especially in Falaba), but I think it's good enough for unofficial use. I also didn't separate out all the new Chiefdoms - only the ones that affected the District boundaries. Since I was making these updates anyway, I decided to try to track down info on the two even newer Districts announced this year. For Bandajuma District, I found this Facebook post from Oct 1, and for Kpanguima District I found this Facebook post from a couple weeks ago, so this is what I based my updated map on. I only had to split out one Chiefdom for these: Jahn Chiefdom (which was also established in 2017 but not included in the data). If you'd like to practice identifying these new Districts and their capitals (as well as the old ones), you can try out my geography game on my GitHub here. The updated GeoJSON I created is also released on the GitHub. If you happen to know of a good, accurate source of the "new" Chiefdoms (from 2017/2018, or even better, from 2026 since several new Chiefdoms were made this year, too), please let me know!

  43. SEEKING WORK | Web dev | Gijon, Spain, UTC+2 | Remote | Ru / Eng Skills: TypeScript, Java, React, Vue, Three.js / WebGL, SQLite, PostgreSQL, + Design/UI/UX, CI/CD, OOP, TDD, AI / Claude Code Résumé/CV: https://konfrontend.github.io/ Email: konfrontend@gmail.com Github: https://github.com/konfrontend Telegram: @cossa91 I'm a full stack generalist, specializing computer graphics / interactive 3d experiences. Looking for a contract or freelance as frontend / full stack dev. Would love to join a startup or a game development team. Have a nice one!

  44. Redditu/sachit324 · r/SideProject · 1 point · sachit1751-art/Audify

    [DEV] Audify — A free, open-source Android music player Hey everyone, I'm the developer of Audify, an Android music player I've been building. It's free, open source (GPL-3.0), and has no advertisements or in-app purchases. Some features include: - Local music playback and playlist management - Lossless audio support - Synced lyrics - Music discovery - Crossfade and Automix I'd appreciate feedback from people who care about privacy-friendly, open-source Android apps. I'm happy to answer questions about the project.

  45. Redditu/Organic_Explorer1186 · r/n8n · 74 points · 17 comments

    I built a full social media pipeline on n8n: news → LLM drafts → Telegram approval → X/Facebook (self-hosted, open source) Poster is a self-hosted app built around an n8n (Community Edition) workflow, with a small Node.js web panel in front. A few design decisions that might be useful for your own workflows: - n8n never sees third-party API keys. The panel stores the secrets; the workflow asks the panel for LLM text and images, and other API calls go through a small gateway in the panel that adds the keys. Workflow exports and execution data contain no API keys. - Every publishing node continues on error, and a final Code node builds one report per run. One failing platform never blocks the others, and a retry (🔁 in Telegram) re-sends only the failed ones. - The workflow JSON is generated: a Python build script plus plain .js files for the Code nodes, with checks for node names and $('…') references. CI validates the result against the n8n version from docker-compose, so nobody hand-edits a huge JSON. - Human in the loop through Telegram: drafts arrive with ✅/❌ buttons, and approval triggers publishing. 3-minute demo: youtu.be It runs 24/7 on a NAS or any Docker host (one-command install, which also sets up Docker on a clean Ubuntu/Debian server). The free LITE edition (AGPL) has one news bot publishing to X and Facebook; there's also a paid PRO edition with more bots and platforms. Code: imdangro/poster-app · Website: posterapp.pl Happy to answer questions about the workflow structure. (Node names are in Polish – it's a Polish project; the app itself is in English and Polish.)

  46. X@wooing0306 · 16 views

    Submitted Shotomatic to the deal. Last year it was amazing. Wonder what it will be like in 2026! Awesome-Black-Friday-Cyber-Monday#2433

  47. X@YoDevp · 8 views

    Detalle que me gusta: si la config no carga, muestra el error redactado y no sale a probar hosts adivinados. La 0.166 (29 oct) también trae codex queue --resume: encola un mensaje y reanuda un hilo que no estaba cargado. Release: github.com/openai/codex/releases/tag/rust-v0.166.0

Older posts →