Pixel

Pixel Updates & Events

Server Updates & Events

Announcements

Buburu: Building a Women’s Safety App in 48 Hours

DEV Community

Buburu: A Women's Safety App Built in 48 Hours, Born From a Walk We Never Forgot.

This is a submission for the MLH x DEV Writing Challenge. Buburu is an app for women’s safety that we decided to create to help women feel safe during their walks. We named the app Buburu and its users ladybugs because there is not only one ladybug who saves Paris: we are all ladybugs who can save the world. The interface follows that theme, and users can choose their own colors. 🐞 We built the frontend with Java Script, React and Leaflet, used Java, Spring Boot for the backend, and stored our data in H2. Auth0 handled sign-in, OpenStreetMap provided the map, and OpenRouteService calculated walking routes. https://github.com/AmeliaDrag/UNIHACK2026 Why we built it During our first week at university in Timișoara, we went out to explore the city and get to know each other. A naked man started following us. A stranger who was walking his dog noticed what was happening, stayed with us, and walked us home. That story had a happy ending only because the man walking his dog had good intentions. It could have been much worse, and for many women it is. In a survey of 1,694 women in Romania aged 18 to 65, 95% said they had been harassed on the street (as reported by F-Sides). Across the EU, about three in ten women aged 18 to 29 (28.3%) reported having experienced stalking in 2021 (Eurostat). After that night, I wanted an app where my mom, my friends, and the girls I know could look out for each other. At our hackathon, we had 48 hours to build a first version. How we built it, step by step Sketch the flows. We drew the main screens on paper and worked out how people would move between the map, reporting, the account page, and SOS. Split the work. One teammate owned the Java backend. We divided the frontend by screen so we could work in parallel. Prototype the interface. After the team discussed what each screen should do, I laid out the pages. We used Canva, Figma, and AI tools to explore the design and develop the ladybug theme. Build the screens and connect the API. We used React 18 with JSX, Vite for local development and builds, Leaflet and React Leaflet for the map, the Auth0 React SDK for sign-in, and plain CSS for styling. The backend, in the words of the teammate who built it I built the backend with Java 21 and Spring Boot, using H2 to store users, trusted contacts, incident reports, and SOS alerts. Each report stores its coordinates, type, and expiry time. Trusted contacts are directional. If Ana invites Maria and Maria accepts, Maria receives Ana’s SOS alerts. For Ana to receive Maria’s alerts, Maria needs to invite her separately. For each walking route request, the backend queries active reports and converts their circular map zones into polygons for OpenRouteService. Computing those polygons on demand means expired reports are automatically excluded from the next request. If no route is found, the backend retries once without the avoidance polygons and returns avoidsReports: false, which the frontend uses to warn that the fallback route may cross reported areas. For the demo, the backend loaded a local OpenStreetMap export at startup to populate the 24/7 shop layer without a live data request. The hardest bug: Debugging the sign-in flow Clicking Sign in sent us back to the first page. In one attempt, the Account screen displayed Invalid state. While sign-in was broken, we couldn't test incident submission or SOS through an authenticated account. We first added type="button" to rule out an accidental form submission. The buttons were already outside a form, so we moved on to the app’s session state and the Auth0 callback. Stale guest state. A leftover guest flag could hide the sign-in controls. The app now checks that guest mode is actually enabled before honoring the flag. Two callback handlers. Both main.jsx and Auth0Provider handled the redirect. We removed the one in main.jsx so the provider owns the callback. API authorization. We fixed the app’s API authorization in the Auth0 dashboard and surfaced sign-in error...

Powered by Readybot.io

Buburu: Building a Women’s Safety App in 48 Hours

Cloud Run vs GKE: Choose the Right Container Platform

DEV Community

Cloud Run vs GKE: Picking a Home for Your Containers

A small API with spiky traffic and a 20-service platform need different things Imagine two teams. One has a small product API that is quiet at 3 am and busy at lunch. The other runs about 20 microservices for checkout, payments and orders, with steady traffic all day and strict rules about which service can talk to which. Both have Docker images ready. Where should each one run? The problem The same container can run on Cloud Run or on GKE (Google Kubernetes Engine). Picking the wrong one hurts in a predictable way: Put the small spiky API on GKE, and you pay for node VMs that sit idle at night, and someone has to look after a cluster. Put a large, tightly networked platform on Cloud Run, and you can end up fighting for control you do not have: sidecars, pod-level network rules, node pools tuned for a sale. The choice is not about which tool is better. It is about traffic pattern and how much control you need. The solution: choose by traffic and control Cloud Run is serverless. You deploy a container and Google runs it. Scales to zero when idle, and adds instances when traffic arrives. Billed per request and compute time, so a quiet night costs close to nothing. Best for stateless services with spiky traffic. Scaling is set at deploy time: gcloud run deploy product-service \
- -image=REGION-docker.pkg.dev/PROJECT/repo/product-service:a1b2c3d \
- -min-instances=0 --max-instances=20
GKE is managed Kubernetes. You run pods on nodes. You pay for node VMs that are always on, plus a cluster fee. Best for steady load, sidecars and strict networking such as Kubernetes NetworkPolicy ("payment accepts traffic only from checkout"). Scaling has layers: the HPA adds pods when CPU crosses a target, and when nodes fill up, the Cluster Autoscaler adds nodes. Both shrink after the peak. How each one sits behind the load balancer Both can sit behind the same External Application Load Balancer, but they attach differently. Cloud Run GKE Attached via Serverless NEG Pod NEG LB health checks None to configure Yes, on pods Who spreads load across instances Cloud Run The LB, straight to pods Scaling Cloud Run autoscaling HPA for pods, Cluster Autoscaler for nodes You manage Very little Cluster, nodes, YAML Applying it to the two teams The small spiky API goes on Cloud Run. It scales to zero at night and scales out at lunch on its own. There is no cluster to patch and no node pool to size. The 20-service platform probably goes on GKE, at least for the core services. With that many services talking to each other, the team benefits from Kubernetes networking rules, sidecars and the ability to pre-scale node pools before a known sale. In a Flipkart-style example design, checkout runs on GKE so the team controls pod counts and node pools, while product and auth stay on Cloud Run because they need less tuning. A mixed setup is normal. One load balancer and one URL map can send /api/product/ to Cloud Run and /api/checkout/ to GKE pods. Trade-offs and limits Twenty services is not an automatic GKE. If those services are stateless and loosely coupled, Cloud Run can run all of them. I would ask what the team actually needs from Kubernetes before paying for it. Cloud Run and Cloud SQL connections. Cloud Run can scale to many instances, and each one opens database connections. I would keep a small pool per instance, cap max instances and use pooling. Close the public URL. Every Cloud Run service has a public run.app address that skips the load balancer. I would set ingress to internal and Cloud Load Balancing. GKE needs pre-scaling for known spikes. At max replicas, requests queue, latency rises, then the load balancer returns 503. For a planned sale I would raise minimums before it starts. Watch idle clusters. A forgotten practice GKE cluster keeps billing. A budget alert does not stop anything by itself, but it tells you early. Takeaway Cloud Run: spiky, stateless, little to manage, pay per use. GKE: many services, steady load, control over pods, node...

Powered by Readybot.io

Cloud Run vs GKE: Choose the Right Container Platform

Software Handover Checklist: Essential Documents

DEV Community

What documents should we get at software handover?

At software handover you should receive all functional and non-functional requirements documents, system architecture descriptions, test approval records, deployment documentation, and administrative credentials. On our projects, at handover the client receives the source code, the documentation, the tests and every credential. The SWEBOK Guide describes a software requirements specification as the basis for agreement between customers and suppliers on what the software is to do and what it is not expected to do. What are the documents needed to handover? A proper software handover provides your business with operational independence. When technical contractors complete custom software development, your organisation must receive tangible artefacts that make maintenance straightforward. Without thorough technical documentation, simple upgrades or maintenance tasks require contacting the original programmers, creating vendor lock-in that drives up operational expenditure. On every project we deliver, you own the source code, the data, the documentation and every credential, with no lock-in and no black box. These documents include the technical design records, operational deployment guidelines, automated test instructions, and administrative manuals needed by internal engineers to operate the software without external reliance. Clear operational documentation ensures continuity for corporate leadership across staffing changes. If internal staff changes occur, incoming technical personnel can review existing records and maintain application stability immediately. When systems lack thorough handover packages, companies risk severe operational bottlenecks during routine maintenance and security updates. A complete handover file also includes the original requirements baseline, showing exactly what functions were requested, approved, and verified. When leadership retains structured specifications alongside repositories, auditing application capabilities requires no guesswork from new personnel, preserving institutional memory and protecting capital investments. What documents are required for software development? Before engineering begins, we produce a Business Requirements Document, a Software Design Document and a functional and non-functional software requirements specification, agreed with you before engineering begins. These formal files set concrete expectations across engineering, operational, and commercial teams. A Business Requirements Document captures what the business needs and why. The document establishes practical commercial objectives and clarifies core operational pain points. Documenting workflows prevents unaligned development sprints and preserves development momentum across commercial milestones by creating a clear business baseline. Meanwhile, a Software Design Document describes how the software will be built to meet the requirements. It outlines system interfaces, database structures, application layers, and server infrastructure configurations before programming starts, giving engineering teams a shared blueprint to follow. Our software requirements specification sets out the functional and non-functional requirements, aligned with ISO/IEC/IEEE 29148. For deeper discovery preparation, explore our guides on software development process to understand how structured planning protects schedules and budgets. Retaining these requirements specifications at final handover allows your engineers to understand historical architectural trade-offs. It shows what functional constraints shaped the current design, making future revisions transparent and enabling any capable development team to extend the software efficiently. How do requirements specifications protect technical scope? Software requirements specification establishes the basis for agreement between customers and contractors or suppliers on what the software product is to do as well as what it is not expected to do. This baseline helps both parties avoid...

Powered by Readybot.io

Software Handover Checklist: Essential Documents

respirAI: A DIY AI Stethoscope Built in a Weekend

DEV Community

We built a talking stethoscope in a weekend. The hardest bug was the word "Great!"

At UniHack 2026 our team built respirAI: a low-cost digital stethoscope that guides you through recording your own lung sounds, screens them with a neural network on your phone, and tells you whether they sound normal or are worth showing to a doctor. It is a screening aid built by students, not a medical device. Try it: https://denis-furtuna.github.io/respirAI/ (there is a practice mode, no device needed) Code: https://github.com/denis-furtuna/respirAI This post is how we built it, step by step, and the bug that cost us the most sleep. The problem A stethoscope is only useful when a trained ear is on the other end. We wanted the opposite: a device that anyone can hold on their own chest, with the phone doing the guiding and the first round of listening. Step 1: the device No custom board. A regular stethoscope chest piece sits on an INMP441 MEMS microphone, wired to a Seeed XIAO ESP32-S3 with a small LiPo battery. The firmware captures audio at 16 kHz, downsamples it to 8 kHz and streams it over Bluetooth Low Energy in 10 ms packets: a 2-byte sequence number followed by 160 bytes of 16-bit mono PCM. The sequence number matters more than it looks. BLE drops packets, and a lung recording with silent holes in it is worse than no recording, so the app counts what is missing and refuses a recording that has too many gaps. Step 2: the app The app is plain JavaScript, HTML and CSS with no framework. In a browser it talks to the device with Web Bluetooth; the same code is wrapped with Capacitor into an Android app. A check goes through the chest positions one at a time. For each one, a body diagram shows where the chest piece goes, then a breathing circle takes over the whole screen and paces two slow breaths while the device records for 12 seconds. The app runs in five languages. Two decisions we would make again: A practice device. A fake Bluetooth device that plays stored recordings let us build and test the whole flow without hardware in hand, and it is why the browser tests can run on every push. Fixed interfaces first. We wrote down the BLE packet format and the app-to-AI contract on day one, so firmware, app and AI were built in parallel on separate branches and merged at the end. Step 3: the AI The model is a convolutional network trained on the ICBHI 2017 respiratory sound database (920 recordings from 126 participants). It looks at a log-mel spectrogram of each recording and flags crackles and wheezes. Two rules we held to. We trained on sound labels, not disease labels, because the disease labels are dominated by one condition and a model can score well by always guessing it. And we split by patient, never randomly, because a random split puts the same person in training and test and inflates every number. Step 4: the voice guide Here is the thing we missed at first: the person's hands are busy. They are holding a chest piece on their own back. They cannot tap "start". So we added a voice guide on top of the flow, using an ElevenLabs conversational agent. It says where to put the chest piece, hears "ready", starts the recording through a client tool, answers questions like "where exactly?", and reads the result. The timer, the breathing circle and every button stay in our code; the agent only speaks and presses two buttons. Offline, the same switch plays pre-recorded instructions instead. One rule is absolute: while the stethoscope records, nobody talks. The phone microphone is muted and the agent's volume is zero, otherwise the stethoscope records the voices too. The hardest bug: the agent kept getting cut off The flow looked simple: The person says "ready". The agent calls our start_recording tool. The tool answers: "tell the person to breathe slowly and stay silent". We wait until the agent has finished saying that. We mute everything and record. Step 4 was the bug. The agent would start "Now breathe slowly, in and out with the ci" and go silent. Every time. Our first version of "wait until it finished" was the obvi...

Powered by Readybot.io

respirAI: A DIY AI Stethoscope Built in a Weekend

Embla 1: A Fast, Private AI Model for Your Phone

DEV Community

Embla 1: A Reasoning Model That Runs on Your Phone — Private, Offline, and Genuinely Fast

Embla 1: A Reasoning Model That Runs on Your Phone — Private, Offline, and Genuinely Fast AI disclosure: This article was drafted with AI assistance and checked against Sevren's own launch blog and architecture post, read 15 November 2026. I have not run Embla 1 hands-on — nobody outside Sevren has had it long enough. Nothing here is sponsored, and there are no affiliate links on this page. Sevren, a Copenhagen startup, has released Embla 1: a reasoning model designed to run entirely on a phone. Private, offline, and free per request — no API call, no server round-trip, no per-token bill. If that sounds like the pitch every on-device model makes, the difference here is the evidence Sevren published alongside it: a full architecture write-up, a training recipe, and benchmark numbers measured on an actual iPhone, including the places where their model loses. That last part is why this launch is worth your attention. Most small-model launches hand you a cherry-picked leaderboard. Sevren handed us their model's weaknesses too. What Embla 1 actually is Embla 1 is a 10-billion-parameter mixture-of-experts model with only about 1 billion parameters active per token (that's the "A1B" in its size class). It's a reasoning model — it thinks through problems step by step before answering — built from the ground up for phone hardware rather than shrunk down from a server model. The headline numbers, all measured by Sevren at 4-bit precision: 57.4 average across five benchmarks: BFCL (tool use), IFBench (instruction following), AA-Omniscience, GPQA (graduate-level science questions) and MATH-500. 1.77 seconds end to end on an iPhone 18 Pro for a 1,024-token prompt producing 256 output tokens, using Sevren's own Metal implementation. In llama.cpp the same task takes 2.18 seconds. 888 tokens per answer on average — the fewest of any reasoning model Sevren tested. The next-cheapest, Gemma 4 E4B, needed 1,577 tokens for the same answers. Qwen3.5-4B needed 6,619. That last number is the one developers should care about most. On a phone, every token costs battery and time. A reasoning model that reaches a good answer in 888 tokens instead of 6,600 is not a little faster — it's a different class of product. It's the difference between an assistant that feels instant and one that makes you watch a spinner. The honest caveats (read these first) Sevren's numbers are Sevren's numbers. They say so themselves, and the caveats matter: Self-measured, one phone, one harness. All benchmarks were run by Sevren on a single iPhone 18 Pro, with an uncertainty of about ±1 point per average. Other setups may rank the models differently. No independent lab has verified these results yet. Five of the twelve models Sevren tested scored higher. LFM2.5-8B-A1B is 1.4 points ahead (58.8 vs 57.4) — but takes twice as long. LFM2.5-2.6B, Granite 4.2 3B, Gemma 4 E4B and Qwen3.5-4B are 2.6 to 5.3 points ahead, but take 3.0 to 5.5 times as long. Embla 1 trades a few points of accuracy for a large speed advantage. Whether that trade is right depends on what you're building. Math is the weak spot. Embla 1 scores 76.1 on MATH-500, against 89.6 for LFM2.5-8B-A1B and 90.5 for LFM2.5-2.6B. Sevren says it plainly: "There is still a lot to improve." If your app leans on hard math, this is not your model yet. The latency claim depends on Sevren's own runtime. The 1.77-second figure uses their custom Metal implementation. In the standard llama.cpp runtime it's 2.18 seconds — still fast, but the headline number is tied to their code, not just their weights. None of that makes the launch unimpressive. It makes it checkable — and that's rarer than it should be. Why it's fast: the architecture in plain language Embla 1 is 32 layers, 2,048 wide, with 8 of 96 routed experts plus one shared expert active per token. Four design choices do most of the work: Sevren Sparse Attention. The full-attention layers use ReLU² instead of softmax, which makes about 95% of attention weights exactly zer...

Powered by Readybot.io

Embla 1: A Fast, Private AI Model for Your Phone

Track What Claude Code Actually Tests

DEV Community

Claude Code Said It Ran the Tests. Its Telemetry Shows What Ran

You ask Claude Code to fix a failing checkout test. A few minutes later it replies: "Fixed. The tests pass now." You merge. Then CI goes red, and when you scroll back through the session you can't find the moment a test actually ran. It's a common enough experience that a recent DEV post title sums it up: I Got Tired of Claude Code Saying 'It's Fixed' When Nothing Had Run. The summary at the end of a session is the model's account of what happened. It isn't a record. Claude Code can give you that record. It has built-in OpenTelemetry support, and with it turned on, every tool call becomes an event: which tool, whether it succeeded, how long it took and, if you opt in, the exact shell command. In an earlier article I covered what to log for an AI agent you run in production. This one points the same idea at the agent that writes your code: send its events to a file on your machine, then check what actually ran after the last edit. Everything about Claude Code's telemetry below comes from its monitoring documentation. What Claude Code can record Telemetry is off until you set CLAUDE_CODE_ENABLE_TELEMETRY=1. Claude Code then exports metrics (token and cost counters, sessions, commits) if you configure a metrics exporter, and events if you configure a logs exporter. The events are what matter here: claude_code.user_prompt is logged when you submit a prompt. The prompt text is redacted unless you set OTEL_LOG_USER_PROMPTS=1. claude_code.tool_result is logged when a tool finishes. It carries tool_name, success ("true" or "false"), duration_ms, and an error_type such as ShellError when the tool failed. claude_code.tool_decision is logged when a permission decision is made. A call you reject produces this event with decision: "reject" and no tool_result, because the tool never ran. claude_code.api_error and claude_code.api_retries_exhausted tell you when requests to the model failed after retries, which explains some sessions that simply stall. Two attributes tie it together. Every event produced while Claude Code works on one prompt shares a prompt.id, so you can pull up everything that happened for "fix the checkout test" in one filter. event.sequence is a counter that orders events within a Claude Code process. By default, the tool_result event tells you that Bash ran, not what it ran. Commands are part of the detail you have to opt into with OTEL_LOG_TOOL_DETAILS=1. With it set, a Bash event gets a tool_parameters JSON string containing full_command, and every tool's arguments are added as tool_input. Step 1: Run a collector that writes to a file You don't need a dashboard to start. The OpenTelemetry Collector can receive Claude Code's events over OTLP and write them to a local file with its file exporter. This config is all it takes (I used otelcol-contrib 0.165.0): receivers:
otlp:
protocols:
grpc:
endpoint: localhost:4317
http:
endpoint: localhost:4318

exporters:
file:
path: ./claude-events.jsonl

service:
pipelines:
logs:
receivers: [otlp]
exporters: [file]
Start it with otelcol-contrib --config collector.yaml. With the default format: json, the exporter writes newline-delimited OTLP JSON, one line per batch. Binding to localhost keeps the receiver off your network. Note that the file exporter is marked alpha for logs, and its README says exact field names aren't guaranteed to stay stable. Step 2: Point Claude Code at it In the shell where you start Claude Code: export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_LOGS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
export OTEL_LOG_TOOL_DETAILS=1
claude
This is the docs' logs-only configuration plus the tool-details flag. To check it works, submit a prompt and look for a user_prompt event in the file. If nothing arrives, the docs suggest starting Claude Code with claude --debug-file and looking for [3P telemetry] errors in that log. A word on what...

Powered by Readybot.io

Track What Claude Code Actually Tests

Fix GitHub Actions Artifact Not Found Errors

DEV Community

GitHub Actions Artifact not found for name on download

A GitHub Actions Artifact not found for name error is a search that came back empty: actions/download-artifact asked for artifacts matching one name and got none. The scope of that search is the whole story, because unless you pass a token it covers exactly one run in one repository. The default search covers one run in one repository. Every input that widens it has to be set, and two of them only work together. What this error means A job that has nothing to do fails immediately, usually the first job downstream of a build. The step log is short: a line saying it is downloading a single artifact, the with: block echoed back, and then the failure. The text arrives on three lines and only the first names your artifact. The other two are a standing hint printed on every occurrence of this error, so they are not evidence about your run. The producing job is usually green, which is the confusing part, because a green upload step is not the same thing as an upload that happened. ```Actions log, quoted from opentelemetry-js-contrib#3297 Error: Unable to download artifact(s): Artifact not found for name: compile-cache-1928 Please ensure that your artifact is not expired and the artifact was uploaded using a compatible version of toolkit/upload-artifact. For more information, visit the GitHub Artifacts FAQ: https://github.com/actions/toolkit/blob/main/packages/artifact/docs/faq.md

Common causes

The producing job never uploaded anything

A skipped job, a failed job, or an upload whose glob matched nothing all leave the run with no artifact. The last is the quiet one: the default behavior of an empty match is a warning, so the producing job goes green and the first red step is this one, in a different job, minutes later.

The names differ, usually by a matrix suffix

In our experience this is the single most common cause since version 4, because version 4 forced matrix legs to stop sharing one artifact name and the consuming job was often not updated to match. The download takes an exact name, not a prefix, so build will not match build-ubuntu-latest. The fix is either the full name or the pattern input, and the two behave differently on the destination directory.

The artifact belongs to a different run

Anything triggered by workflow_run, anything re-run on its own, and anything reaching across repositories is searching a run that does not hold the artifact. The default scope has no way to express that, so it quietly searches the wrong place and reports the name as missing.

The artifact expired, or was written by version 3

Both are named in the message and both are real. Retention is 90 days by default and can be shortened per upload or per repository, so re-running an old workflow can look for something deleted. Version 3 closed down on 30 January 2025, and artifacts it wrote are not readable by version 4 and later.

How to fix it

Read the run, not the message

  1. Open the run and look at its artifacts panel: it says at once whether the name is wrong or nothing was uploaded.
  2. If it is empty, the fault is in the producing job and this step is only the messenger.
  3. If it holds similar names, it is a mismatch, and the panel shows you the real ones.
  4. If the names are right, check whether the download is pointed at that run at all.

Match the name, or ask for the pattern

The corrected half of the illustrative pair above. Downloading by pattern with merge-multiple puts every matching artifact into one directory, which is what most consumers of a matrix build want. Without it, each artifact lands in its own subdirectory named after it.

```.github/workflows/ci.yml, corrected (illustrative)
publish:
needs: build
runs-on: ubuntu-latest
steps:
- uses: actions/download-artifact@v8
with:
path: dist
pattern: build-
merge-multiple: true
- run: ls -R dist
Make an empty upload fail where it happens The default for an upload that...

Powered by Readybot.io*

Fix GitHub Actions Artifact Not Found Errors

Why SQL Formatting Makes Code Reviews Safer

DEV Community

The one-line SQL query that broke code review

I once reviewed a pull request where the entire database migration was one line. Four hundred and twelve characters of SQL, no line breaks, no indentation, a JOIN buried somewhere in the middle like a landmine. The query was correct. It also took me twenty minutes to be sure it was correct, because I could not read it. That is the whole case for a SQL formatter. It does not make your query faster. It does not fix your logic. It makes the query readable enough that a human can spot the bug before it ships. Formatting is not cosmetic A formatter does two honest things. First, it puts one clause per line: SELECT, FROM, WHERE, GROUP BY, ORDER BY. Second, it indents the parts that belong together, so a JOIN condition sits under its JOIN and a subquery is visibly nested inside its parent. That is it. No magic, no rewriting. The formatted query does exactly what the original did, because only whitespace and casing changed. The bug I was hunting in that PR turned out to be a missing condition in the WHERE clause. On one line, the WHERE clause looked like a wall of text and my eyes slid right past it. Formatted, the missing condition was obvious in about four seconds, because the list of conditions was vertical and one item was simply absent. The dialect trap nobody warns you about Here is where most people pick the wrong formatter: SQL is not one language. MySQL uses backticks for identifiers. SQL Server uses square brackets. PostgreSQL uses double quotes. BigQuery has its own ideas about everything. A formatter that does not know your dialect will happily "fix" syntax that was never broken, or choke on syntax that is perfectly valid in your database. So the first question a good formatter asks is not "how many spaces" but "which database". Standard SQL, MySQL, PostgreSQL, SQLite, SQL Server, Oracle, BigQuery, Snowflake, Redshift: each one parses differently. If your formatter treats them all the same, it is guessing, and guessing with production queries is a bad habit. Minify is the opposite direction, and it has a use Formatting spreads a query out. Minifying crushes it into one line. That sounds like going backwards, until you need to paste a query into a URL parameter, a log line, or a config value where newlines are not welcome. Minify is a transport format, not a reading format. The rule is simple: format for humans, minify for machines, and never confuse the two. One warning about minifying: a careless minifier will strip a comment that your query actually needs, or join two tokens that were only separated by whitespace. A good one leaves string literals and comments alone. If yours does not, find another one. Your queries should never leave your browser This matters more than people admit. The queries you format are often production queries. They contain real table names, real column names, sometimes real customer IDs baked into a WHERE clause. A formatter that uploads your SQL to a server to format it is a data leak wearing a tool costume. The safe version runs entirely in your browser. Paste, format, copy, done. Nothing is uploaded, nothing is stored, nothing is logged. If a tool cannot promise that, do not paste production SQL into it. I built a free one that works exactly this way, with dialect selection, keyword casing, indentation options and a minify mode: it formats MySQL, PostgreSQL, SQLite, SQL Server, Oracle, BigQuery and more, all in your browser. You can try it here: https://www.theutilityhub.online/tools/sql-formatter A small habit that pays off Before you paste a query into a pull request, a migration file, or a chat message to a colleague, run it through a formatter. It takes three seconds. The person reading it, which is often future you, will be able to see the structure instead of decoding a wall of text. And the next time a WHERE condition goes missing, you will spot it in four seconds instead of twenty minutes.

Powered by Readybot.io

Why SQL Formatting Makes Code Reviews Safer

Claude Frontend Design Skills: Save Your Style Rules

DEV Community

Claude skills for frontend design: stop re-typing your design rules

If you build sites with Claude Code, you have probably written the same paragraph a dozen times: "use one accent color, left-aligned hero, no gradient blobs, real spacing scale, subtle motion only." It works for that one prompt. Next session, it's gone, and the agent drifts back to the average-looking page. Claude skills for frontend design fix exactly this. Instead of pasting your taste into every prompt, you package it once and let the agent load it when the task calls for it. What a skill actually is A skill is a folder with a SKILL.md file. The top of the file holds a name and a one-line description. That description is the sentence the agent uses to decide when to reach for the skill. Below it, you write your steps in plain text. The agent doesn't load every skill into every conversation. It reads the descriptions, and only pulls in the full instructions when your request matches. That means you can keep a dozen narrow skills around (frontend design, icon sets, GSAP animation, video rendering) without bloating every session. Because it's just a folder of text, the same skill works in Claude Code, Codex and Cursor. Where to put it Claude Code reads skills from two places: ~/.claude/skills/ for every project .claude/skills/ inside a single project Create the folder if it isn't there, drop the skill folder in, and restart the agent. There's no command to memorize; the next time you ask for something that matches the description, the skill kicks in. On Claude.ai you add skills under Settings → Customize → Skills instead. Writing a tiny frontend design skill yourself You don't need anyone else's skill to start. Here's a minimal one you can adapt: ---
name: house-style-frontend
description: "Use when building or restyling any web page, landing page or UI component in this project."

  1. Layout: left-aligned hero, max content width 1200px, 8px spacing scale.
  2. Type: one display font for headings, one body font. Headline max 8 words.
  3. Color: near-black background, one accent color (#FF5A1F), no gradients behind text.
  4. Components: no emoji icons, no three-identical-cards row unless asked.
  5. Motion: fade/slide on scroll only, under 400ms, respect prefers-reduced-motion.
  6. Before finishing, list any rule you broke and why.
    The last line is the useful trick: asking the agent to report its own rule-breaks turns a vague "make it look good" into something you can review. Keep the description specific. "Use for frontend" is too broad and will fire on everything; "Use when building or restyling a web page in this project" is easier for the agent to match correctly. Read before you install A skill runs with your agent's permissions. Before you drop someone else's folder into ~/.claude/skills/, open the SKILL.md and read the whole thing. Check the license and the author, and be wary of skills that ship scripts you don't understand. Good skill pages show the full SKILL.md before you download. Skills vs. prompts They solve different problems: A prompt describes one page: this hero, this pricing table, this product. A skill describes how you build every page: the rules that should hold no matter what you ask for. The combination is where AI-built sites stop looking AI-built. The skill keeps the baseline consistent; the prompt carries the specific design for the page in front of you. Where to find more At MotionSites we collect open-source Claude and Codex skills for frontend design, motion graphics and video, grouped by what you want to build, with the install command and license for each and a demo on most. Most are free to download: motionsites.org/skills. Start with one small house-style skill like the one above. Once you notice the agent following your rules without being reminded, you'll want a few more.

    Powered by Readybot.io
Claude Frontend Design Skills: Save Your Style Rules

Fixing Sharp libvips Errors on Vercel

DEV Community

sharp on Vercel: "libvips-cpp.so: cannot open shared object file" when the install was clean

Our first production deploy of Brifora (an AI design studio built with Next.js and Supabase) looked perfect — until every route that used sharp started returning 500. The symptom. The function crashed while loading the module, before the first line of the handler ran. The Vercel runtime log said: Error: Could not load the "sharp" module using the linux-x64 runtime
ERR_DLOPEN_FAILED: libvips-cpp.so.8.18.3: cannot open shared object file:
No such file or directory
The build log was clean: all packages installed, no optional dependency skipped, and the lock file had both Linux entries with the right os and cpu. Read which file is missing. Not sharp, not its native binding — libvips-cpp.so. That detail is the whole story. The cause. Since sharp 0.34, libvips ships in a separate package, @img/sharp-libvips-. The binding loads it through an rpath at dlopen time. Nothing ever requires it, so Next's output file tracing doesn't see it and doesn't copy it into the serverless function. (serverExternalPackages is not the problem — sharp is already external, as the error itself shows.) The fix. Tell the tracer explicitly, in next.config.ts: outputFileTracingIncludes: {
'/api/generate': ['node_modules/@img/'],
'/api/uploads': ['node_modules/@img/
'],
'/api/vectorize': ['node_modules/@img/'],
'/api/edit': ['node_modules/@img/
'],
'/api/maintenance/sweep-uploads': ['node_modules/@img/'],
},
We listed routes by name instead of '/
': libvips weighs tens of megabytes, and the login page or the gallery has no use for it. Act two, two days later. The same error came back — this time on two pages, not API routes. They don't process images at all. But they imported a couple of constants (UPLOAD_MAX_BYTES, UPLOAD_TYPES) from our uploads module — and that module imports sharp. A constant pulled the whole native dependency in with it. We had a comment in the config saying "don't forget to add new routes here". It didn't help: the person who wrote the comment was the person who forgot. So we replaced the comment with a check — a command whose output must have as many lines as there are @img entries in the config: grep -rln "generation/uploads'|generation/preview'|generation/svg'|generation/sources'" src/app/
Takeaways: A clean install log doesn't mean a native library reaches your serverless function. The tracer follows require, not rpath or dlopen. Read exactly which file is missing: libvips-cpp.so and sharp.node point to different problems. A hand-maintained list of exceptions will go stale. Replace "remember to update this" comments with a command that checks it. Importing a constant from a module imports its heavy dependencies too. Keep constants in a light file. Brifora: https://brifora.app — built by Weblevo (weblevo.com)

Powered by Readybot.io*

Fixing Sharp libvips Errors on Vercel

Use AI as a Teammate: A Better Developer Workflow

DEV Community

Use AI Like a Teammate, Not a Search Engine

Most people use AI like a search engine: ask a question, get an answer, close the tab. That works for quick lookups, but it leaves most of the value on the table. The developers getting the most out of AI treat it like a teammate. Here is the approach I use after completing Anthropic's courses on AI Fluency, Claude Code and Agent Skills. 1. Give it a goal, not a prompt "Write a function that validates emails" is a prompt. "Our signup form accepts invalid emails and support is getting complaints; find where validation happens and fix it" is a goal. The second gives the AI context, a problem and a definition of done. 2. Let it plan the steps Ask for a plan before any code is written. Reviewing a five-line plan is far cheaper than reviewing a wrong 500-line change, and it surfaces misunderstandings early. 3. Give it the right tools and skills An assistant that can read your project, run tests and follow your team's conventions beats one working from a pasted snippet. Agent skills are a good way to package repeatable instructions, such as your code style or deployment checklist, so you do not re-explain them every session. 4. Review the output, do not just accept it AI can be confidently wrong. Read the diff, run the tests and check edge cases. You stay responsible for what ships. The takeaway AI does not replace your judgment, it multiplies it. The better you define the problem, the better the result. How are you using AI in your workflow: search engine or teammate? Let me know in the comments.

Powered by Readybot.io

Use AI as a Teammate: A Better Developer Workflow

React Native WhatsApp UI Clone with Expo

DEV Community

WhatsApp UI Clone in React Native with Expo – Complete Mobile App UI Project

WhatsApp UI Clone in React Native with Expo – Complete Mobile App UI Project Building a messaging application is a great way to improve your React Native development skills. One of the best ways to understand mobile app development is to study how popular messaging applications organize their screens, navigation, and user interactions. In this article, we'll explore a WhatsApp UI Clone built with React Native and Expo. This project recreates the familiar messaging experience with multiple screens, interactive conversations, status updates, contacts, communities, and call history. Whether you're learning React Native, preparing a mobile development portfolio, or looking for a ready-made messaging app UI project, this project can help you get started faster. 🚀 Project Overview This WhatsApp-inspired mobile application is built using React Native and Expo. It focuses on recreating the frontend interface and navigation experience of a modern messaging application. Instead of building every screen from scratch, developers can explore an existing UI implementation and customize it according to their requirements. Project highlights: WhatsApp-inspired user interface Interactive chat list and conversation screens Status and updates interface Contacts management UI Communities interface Calls and call history screen Bottom tab navigation Dummy users and conversations Android and iOS development support through Expo Explore the complete project: https://skillhost.in/projects/whatsapp-app-ui-design-in-react-native/ 📱 Main Features and Screens Let's explore the major screens included in this React Native WhatsApp UI project. 1. Chats Screen The Chats screen is the main interface where users can view their conversations. It includes: User profile pictures Contact names Latest message previews Message timestamps Unread message counters Search functionality Chat filters Archived conversations New chat action The layout follows a familiar messaging application design, making it easier for developers to understand how to organize conversation lists in React Native. 2. Individual Chat Screen The individual chat screen provides the core messaging interface. It includes: Incoming and outgoing message bubbles Message timestamps Read indicators User profile information Online and last-seen status Message input field Send message interaction Emoji and attachment buttons Camera and microphone interface Voice and video call actions Developers can use this screen as a starting point when building their own messaging application. 3. Status / Updates Screen The Updates screen recreates the status-sharing experience. Features include: My Status section Recent status updates User profile avatars Status indicators Status viewer Progress indicators Reply interface This screen is useful for understanding how to organize status updates and their navigation flow in React Native. 4. Contacts Screen The Contacts screen provides a simple interface for browsing users. It includes: Contact list Search by name or number Profile avatars Online indicators Recently online users Favorite contacts Add contact action You can later connect this interface to your own contacts API or backend. 5. Communities Screen The Communities screen provides a starting point for building group-based communication features. It includes: Community introduction Community icons Existing communities Community descriptions Member avatars Create community action Example community categories include friends and family, technology groups, and workplace communities. 6. Calls Screen The Calls screen displays a messaging application's call history interface. It includes: Incoming calls Outgoing calls Missed call indicators Voice call icons Video call icons Call timestamps Create call link interface This is a frontend representation. Actual voice and video calling require additional communication services. 🛠️ Technologies Used The project uses the following technologies: Technology Purpose Reac...

Powered by Readybot.io

React Native WhatsApp UI Clone with Expo

Stop Meeting No-Shows with Free Booking Tools

DEV Community

How to Stop No-Shows Without Paying for Scheduling Software

You know the shape of it. A call is booked for 10:00. At 10:05 you are staring at an empty meeting room, or an empty video link, wondering whether to wait or move on. At 10:15 you give up. The client emails at noon: sorry, forgot. No reminder, no confirmation, no calendar invite — just a time agreed in an email thread three days ago and then forgotten. No-shows are rarely rudeness. They are usually a system failure: nothing reminded the person, nothing put the meeting on their calendar, and nothing made it easy to cancel or move. Why people actually no-show Most no-shows come down to four small failures. First, there was no confirmation email, so the booking never felt real. Second, there was no calendar invitation, so the meeting never appeared alongside everything else in the person's day. Third, there was no reminder close to the time — a meeting agreed on Monday is easy to forget by Thursday. Fourth, there was no easy way to reschedule, so a clash became a silence instead of a moved meeting. None of those is a character flaw. All of them are fixable with a booking page, and none of them needs paid software. What a free booking page already does The team at ExactReads tested Calendly and Cal.com on their free plans with real bookings, and both did the basics that prevent no-shows. Both sent a confirmation email within minutes of the booking — Calendly at 08:34 IST and Cal.com at 09:20 IST on the test day — and both bookings appeared in the dashboard. Both connected to a real calendar, so the meeting existed somewhere the client could see it. Cal.com went one step further in the test. When the Cal.com page was opened for Monday 16 November, it offered 9:00, 9:30, 10:30 and 11:00 — but no 10:00 slot. The Calendly test booking occupies 10:00–10:30 on the same shared Google Calendar, so Cal.com was reading the calendar and blocking the busy slot. That is conflict checking doing its job: it stops the double-booking that creates the second kind of no-show, the one where two people turn up for the same hour. Calendly's free setup has its own guardrails: the event was set for weekdays 9:00 am to 5:00 pm IST with a 60-day date range and four hours' minimum notice, so nobody can book you with no warning. A no-show routine that costs nothing You do not need a paid plan to run this. Sign up with Google — neither tool asked for a card or a business email in the test. Create one 30-minute event type called "Intro call". Connect your real calendar. Set a minimum notice period of four hours so a booking always leaves you time to prepare. Then book a test slot yourself through the public link and check the confirmation email arrives. If it does not, fix it before a client ever sees the link. Then change one habit: stop offering times in email. Send the link instead. The client picks a slot that is genuinely free, the calendar updates, and the confirmation email does the reminding. Your job is to turn up. One honest warning about "free" There is one trap to know about. Cal.com put the test account straight on its free plan, with no trial. Calendly put the new account on a free Teams Plus trial that ends on 30 November 2026, after which it drops to the free limits — one event type, one calendar. If you judge Calendly during the trial, you are judging the paid product. Set a reminder for the trial end date and check what disappears. The full test, with the exact free-plan limits as published on 15 November 2026, is on ExactReads — read it before you choose. A no-show costs you the hour you set aside plus the hour you spend rebooking it. A booking page with a confirmation email and a connected calendar removes most of them for free. More practical guides for small teams are on the ExactReads homepage.

Powered by Readybot.io

Stop Meeting No-Shows with Free Booking Tools

5 WordPress Speed Fixes for Better Core Web Vitals

DEV Community

5 WordPress Speed Fixes That Actually Move Core Web Vitals

A slow WordPress site hurts user experience, conversions and search visibility. After years of building and tuning WordPress and WooCommerce sites, these are the five fixes I reach for first, in order of impact. 1. Fix the Largest Contentful Paint (LCP) element On most pages the LCP element is a hero image. Serve it in a modern format (WebP or AVIF), size it correctly for the viewport, and never lazy-load it. Add fetchpriority="high" so the browser fetches it early.
2. Audit plugins before adding caching Caching masks a heavy site, it does not fix it. Deactivate plugins one by one and measure. Replace multi-purpose plugins that load scripts on every page with lighter alternatives, or load their assets only where needed. add_action( 'wp_enqueue_scripts', function () {
if ( ! is_page( 'contact' ) ) {
wp_dequeue_script( 'contact-form-7' );
wp_dequeue_style( 'contact-form-7' );
}
}, 100 );
3. Reduce layout shift (CLS) Always set width and height on images and embeds, and reserve space for ads, banners and cookie notices. Preload key web fonts and use font-display: swap to avoid text jumping. 4. Defer non-critical JavaScript Third-party scripts such as chat widgets, analytics and trackers often block rendering. Load them with defer or after user interaction, and remove any you no longer use. 5. Use proper caching and a CDN Page caching, object caching (Redis or Memcached) and a CDN cut server response time (TTFB) dramatically, especially for WooCommerce stores where uncached pages are expensive. Exclude cart, checkout and account pages from page caching. Measure, then fix Test with PageSpeed Insights and the Chrome DevTools Performance panel, and check field data in Search Console. Fix the biggest bottleneck first, re-measure, and repeat. What is the biggest performance problem you have run into on a WordPress site? Share it in the comments.

Powered by Readybot.io

5 WordPress Speed Fixes for Better Core Web Vitals

AIA Certificate Links: Security Risks and Safe Handling

DEV Community

Certificate AIA links are path-building hints from untrusted input

Certificate AIA links are path-building hints from untrusted input An X.509 certificate can carry an Authority Information Access, or AIA, extension that tells a relying party where to find issuer information. RFC 5280 defines the extension and the id-ad-caIssuers access method. The URI is useful when a client needs an intermediate certificate that was not delivered in the TLS handshake. It is not a trust anchor, and it is not a statement that the remote server is safe to contact. Path building and path validation are different steps. RFC 4158 describes path building as the process of assembling candidate chains from certificates and potentially untrusted network locations. Validation then checks signatures, policies, name constraints, validity, and other conditions against an explicit trust store. A server that returns a certificate from an AIA URL has supplied an input to the first step, not proof for the second. Treat AIA retrieval as an outbound network request An application that fetches AIA or CRL distribution URLs on demand creates a path from attacker-influenced certificate data to the application's network. The URL may point at an internal address, a slow host, an oversized response, or a redirect chain. The client still has to verify the returned certificate's signature and issuer relationship, but the request itself can expose topology or consume resources. Apply an allowlist or proxy policy for certificate retrieval. Set connect, read, and total timeouts. Limit redirects, response size, and certificate count. Reject unsupported schemes and credentials embedded in URLs. Do not send cookies, authorization headers, or application credentials with the request. Cache successful issuer certificates by subject and key identifier, with a bounded lifetime. When a chain validates from a local trust store, a missing or failing AIA URL should not cause a fallback to an unauthenticated chain. If the product deliberately supports AIA retrieval, make that behavior visible and test it against a hostile URL. A certificate verifier that accepts an issuer because the URL returned it has confused availability with trust. Record the chain decision Log the leaf subject, issuer, authority key identifier, certificate fingerprint, trust store, and the path-building source. Do not log private keys or full certificate bundles. Record whether an intermediate came from the handshake, a local cache, or a network fetch. That distinction matters during an incident review. OpenSSL exposes trust anchors and untrusted certificate inputs separately. openssl verify can be given a trust store, an untrusted chain, and verification options that control path building. The exact flags depend on the application, but the design principle is stable: trust anchors are chosen by policy, not discovered from the certificate being evaluated. Test a certificate with an AIA URI to an unreachable host, a URI to a host that returns the wrong issuer, and a URI to a local service that should not be contacted. Confirm that the verifier returns a bounded failure. Then confirm that a valid local chain still works when the network is unavailable. Keep the boundary explicit The AIA extension is a useful hint for PKI interoperability. It becomes dangerous when certificate data controls a privileged network client. Keep the network fetch narrow, validate every returned object, and preserve the local trust decision as a separate step. References RFC 5280, Internet X.509 Public Key Infrastructure Certificate and CRL Profile RFC 4158, Internet X.509 Public Key Infrastructure: Certification Path Building OpenSSL verification options OpenSSL verify command

Powered by Readybot.io

AIA Certificate Links: Security Risks and Safe Handling

Managed GitHub Actions Runners Compared

DEV Community

Managed GitHub Actions runners compared, by how you pay

Managed GitHub Actions runners compared on rate alone will tell you to pick the cheapest row, and the cheapest row is frequently not the cheapest vendor. What separates them is structural: whose cloud the job runs in, what you still have to operate, and which meters run beside the one on the pricing page. The three commercial shapes in this market and which vendors sit in each. Rates and tiers read from each vendor page on 2026-09-21. Every vendor in this market sells the same first sentence: cheaper and faster than GitHub-hosted, attached with a label change. Most of them deliver it, which is why the sentence is useless for choosing between them. The useful distinctions are three. Where the compute physically runs, because that decides your data path and who gets paged. What the bill is shaped like, because a licence, a meter and a prepaid pool fail differently as you grow. And what the headline rate excludes, because several vendors meter things beside minutes. Three shapes, not one market Fully managed and metered is the shape most people mean: the vendor owns the fleet, you change runs-on, and you pay per minute. Blacksmith, Depot, Namespace, Ubicloud, WarpBuild managed and Latchkey are all this. Setup is a GitHub App connection and a label, and nothing about your cloud account changes. Bring-your-own-cloud is the second shape. The vendor supplies the control plane and the runner image, and the machines are started in your AWS, GCP or Azure account, so the compute bill and the network boundary are yours. WarpBuild publishes this at a flat $0.002 a minute. The third shape is a licence with no meter at all: RunsOn charges from EUR 300 a year at its Starter tier and states that the compute is your AWS bill, not ours, with no markup, billed per second by AWS. Vendor Shape Where jobs run What you still operate Setup change Blacksmith Managed, metered The vendor's cloud Nothing GitHub App plus a runs-on label Depot Managed, metered The vendor's cloud Nothing GitHub App plus a runs-on label Namespace Managed, metered The vendor's cloud Nothing Connection plus a runner profile label Ubicloud Managed, metered The vendor's cloud Nothing GitHub App plus a runs-on label Latchkey Managed, metered The vendor's cloud Nothing GitHub App plus a runs-on label WarpBuild Managed, or bring-your-own-cloud The vendor's cloud, or yours Your cloud account, in BYOC mode GitHub App, plus cloud credentials for BYOC RunsOn Licence, your account EC2 in your own AWS account The AWS account, quotas, AMIs, spot capacity A CloudFormation stack you own GitHub-hosted First party GitHub's cloud Nothing None; it is the default Shapes and setup steps read from each vendor's own documentation on 2026-09-21. The rates behind these rows, with free tiers and billing granularity, are in GitHub Actions runner alternatives; this table deliberately compares structure instead, because two vendors at the same rate can still be different products. The meters beside the meter Three vendors charge for things the minute rate does not include, and on a Docker-heavy or cache-heavy pipeline those lines can be larger than the difference between two rates. This is the part that a rate-card comparison hides, and it is published, so there is no excuse for leaving it out. None of these are traps; they are honest unbundling, and in each case the feature is genuinely optional. They just have to be added before you compare. A pipeline with a 50 GB Docker layer cache on Blacksmith is paying $25 a month for that cache on top of its minutes, and a pipeline restoring a WarpBuild snapshot on every one of 20,000 jobs a month is paying $800 for the restores. Vendor What else is metered Published price Blacksmith Docker layer caching $0.50 per GB per month Blacksmith Sticky disks $0.50 per GB per month Blacksmith Static IPs $100 per IP per month WarpBuild Cache storage $0.20 per GB-month WarpBuild Cache write or restore $0.0001 per operation WarpBuild Snapshot restore $0.04 per job WarpBui...

Powered by Readybot.io

Managed GitHub Actions Runners Compared

Local LLM Runs at 90% Speed with Just 4GB GPU Memory

DEV Community

I Cut Dedicated GPU Memory to 4GB, and a Local LLM Still Ran at 90% Speed

On a Surface Laptop Ultra (RTX Spark, unified memory), I measured local LLM speed and Windows' free memory with the GPU's dedicated memory set to 4, 64, 82 and 96GB. Speed barely moved; memory left for Windows did. This is an English adaptation of an article I originally published in Japanese on Zenn: 専用 GPU メモリーを 4GB にしても、ローカル LLM は 9 割の速さで動いた. The measurements and conclusions are mine; I used an AI tool to help translate and restructure the text, and I checked the numbers against the original. Short version: on this laptop, setting the GPU's dedicated memory to the minimum (4GB) still left a local LLM at about 90% of its speed, while the memory left for Windows changed from 122.5GB to 30.5GB across the settings. A 71-second video summary (narration is synthetic, English captions available): TL;DR This laptop's CPU and GPU share one pool of physical memory. A setting decides how much is dedicated to the GPU, from 4GB to 96GB. The rest is main memory for Windows and apps. With dedicated GPU memory at the minimum 4GB, gpt-oss-120b (63.4GB) still generated 58.8 tokens/s, about 92% of the 63.9–64.2 at 64GB and up. Most of the model sat outside the dedicated part, in memory the GPU borrows from main memory. Memory left for Windows went from 122.5GB (4GB setting) to 30.5GB (96GB setting). At 82GB and 96GB, with the model loaded and a browser open, committed memory reached 99% of the commit limit. Moving MoE experts to the CPU (-ncmoe) was slower than leaving everything on the GPU, even at 4GB: about 2.1–2.6× slower for gpt-oss-120b and 1.8× for the other model. I lowered my everyday setting from 82GB to 64GB. One laptop, two models, one run per setting. On a PC with a separate graphics card (its own VRAM), I'd expect very different results. Setup PC Surface Laptop Ultra (Windows 11 Pro, NVIDIA RTX Spark N1X, 128GB unified memory) How the dedicated amount was changed NVIDIA App, "Dedicated GPU memory (GB)", with a reboot each time. Options ran from 4GB (minimum) to 96GB (maximum) Settings tested 4GB (minimum), 64GB (about the size of gpt-oss-120b's 63.4GB file), 82GB (my setting until then), 96GB (maximum) Driver 621.24 llama.cpp b12110 (CUDA), the same build as my 8-model benchmark Models gpt-oss-120b (MXFP4, 63.4GB), Nemotron 3.5 Bolt (74B total, about 9B active per token, 2-bit, about 22GB) Stopped during the test WSL, ComfyUI and other LLMs. Only at 82GB, an Ollama instance with no model loaded was running What I call each part of memory There is one pool of physical memory, split in two by the setting: Name What it is Dedicated GPU memory The part reserved for the GPU. Set in the NVIDIA App. This is what nvidia-smi reports Main memory The rest. Used by Windows and apps. This is what Task Manager shows as "Memory" Shared GPU memory The part of main memory the GPU borrows when it needs more Dedicated plus main came to 126.5GB at every setting. How I measured At each setting, in the same order: 3 minutes idle, logging free memory and more every 5 seconds. llama-bench, average of 3 runs: pp512 (prompt processing): how fast the model reads a 512-token prompt before answering. tg128 (generation): how fast it writes 128 tokens. Closest to how fast text appears in a chat. A 5-minute load with gpt-oss-120b loaded in llama-server: 10 browser tabs, plus a script grabbing main memory 4GB at a time up to 16GB. Still logging every 5 seconds. I logged Windows performance counters (Available MBytes, Committed Bytes, Commit Limit, page file usage, disk writes) and dedicated GPU memory use from nvidia-smi. Memory sizes from the counters are converted at 1GB = 10^9 bytes. # Everything assigned to the GPU (the main runs)
llama-bench -m .gguf -ngl 999 -fa 1 -p 512 -n 128 -r 3

Some MoE experts on the CPU side (for comparison)

llama-bench -m .gguf -ngl 999 -ncmoe 16 -fa 1 -p 512 -n 128 -r 3
Result 1: about 90% of the speed at 4GB All layers assigned to the GPU (-ngl 999). Tokens per second, average of 3 runs. Dedicated GPU memor...

Powered by Readybot.io

Local LLM Runs at 90% Speed with Just 4GB GPU Memory

Fixing Fork EAGAIN Failures in CI Builds

DEV Community

Fork retry resource temporarily unavailable CI failures

Fork retry resource temporarily unavailable CI failures mean the kernel refused to create a new process with EAGAIN, and EAGAIN in fork(2) is a limit on the number of processes and threads, not a shortage of memory. Count the threads your build is running and compare that against ulimit -u and the cgroup PID limit before you touch the runner size. The two failure paths in bash make_child. The retry loop runs only while errno is EAGAIN, which is why an out-of-memory fork prints once and never prints "retry". What this error means The step prints the same line several times and then a shorter version of it, after which almost every command fails because nothing can start a child process. The repetition is not noise: bash retries on this specific error and prints once before each retry, with a doubling sleep in between, so a step can sit there for several seconds looking hung before it gives up. The last line drops the retry: because it comes from a different branch of the same function, the one that runs after the loop has stopped trying. The prefix is worth reading too. In a workflow run: step it is not the word bash but the path of the temporary script the runner wrote, because bash names the error after BASH_SOURCE[0] whenever it is not interactive. ```Reconstructed from sys_error in bash make_child (jobs.c) fork: retry: Resource temporarily unavailable fork: retry: Resource temporarily unavailable fork: retry: Resource temporarily unavailable fork: Resource temporarily unavailable

Common causes

Nested parallelism multiplied out

The common case, and it is arithmetic rather than a bug. A test runner given one worker per core starts a build tool that is also given one job per core, and each of those starts a language runtime with its own thread pool. On a 4 vCPU runner that is not twelve threads, it is four times four times some pool size, and it can reach four figures without anything looking wrong in the workflow file. The ceiling is reached by multiplication, which is why the same command runs fine on a laptop with a much higher limit.

A container or job with a low pids limit

Running your build inside a container adds a second ceiling. The cgroup PIDs controller enforces pids.max independently of ulimit -u, and it is frequently the lower of the two, so a build that has plenty of headroom by the shell limit is stopped by the cgroup anyway. This is the version that appears when a job is moved into a container and nothing else changes, and it will not reproduce outside that container.

Something is leaking processes or threads

A step that starts a background service on every iteration of a loop, a test suite that spawns a helper per test and never waits for it, or a tool that leaves zombies behind will climb steadily toward the limit rather than jumping to it. The signature is that the failure happens late in a long step rather than immediately, and that it moves earlier as the suite grows. Counting with ps -eLf | wc -l at the start and end of the step turns this from a theory into a number.

The limit is genuinely too low for the work

Some builds legitimately need thousands of threads, and a runner image or container configured conservatively will refuse them. This is the least common of the four and the only one where raising the limit is the right answer rather than a way of postponing the question, so establish it by measurement before you conclude it.

How to fix it

Measure the ceiling and the count, in that order

  1. Print ulimit -u and cat /sys/fs/cgroup/pids.max in the failing step. The effective ceiling is the lower of the two, and inside a container it is usually the second.
  2. Count threads rather than processes with ps -eLf | wc -l, because RLIMIT_NPROC counts threads and ps -ef does not show them.
  3. Sample the count at the start of the step and again just before the failure. A number that climbs is a leak; a number that jumps is parallelism.

```.github/wor...

Powered by Readybot.io

Fixing Fork EAGAIN Failures in CI Builds

A Smarter, More Systematic Debugging Workflow

DEV Community

A Better Debugging Workflow Starts With Asking the Right Questions

Debugging is one of those activities that every developer does regularly but rarely thinks about improving. You encounter an unexpected API response, a regular expression that refuses to match, a database query that takes too long, or a frontend component that behaves differently than expected. The first instinct is often to change something and see whether the problem disappears. Sometimes that works. More often, it creates another problem while leaving the original issue unexplained. A better approach is to treat debugging as a process of investigation rather than trial and error. Here are some practical techniques that can make everyday debugging more systematic and less frustrating. Reproduce the Problem Before Changing Anything The first step is understanding exactly what is happening. Before modifying code, try to reproduce the issue consistently. Ask yourself: Does the problem happen every time? Does it occur only with specific input? Is it environment-dependent? Did it start after a recent code change? Can you reproduce it with a smaller example? For example, imagine an API endpoint that occasionally returns unexpected results. Instead of immediately changing the controller or database query, capture the actual response and compare it with the expected response. A minimal reproduction makes it much easier to identify the responsible part of the application. Inspect the Input Before Inspecting the Logic Many debugging problems originate from unexpected input rather than incorrect application logic. Consider a function that expects a JSON object: { "name": "Alex", "age": 28, "active": true } Everything looks straightforward. However, the actual API response might contain: { "name": "Alex", "age": "28", "active": "true" } The JSON is syntactically valid, but the data types are different. That distinction matters. A frontend component expecting a Boolean might behave incorrectly when it receives a string. When investigating data-related problems, check: The actual input structure Data types Missing properties Unexpected null values Empty strings Special characters Encoding differences For large or deeply nested JSON responses, formatting the data makes inspection considerably easier. A JSON formatter can help identify structural differences and syntax errors before you investigate application logic. Break Complex Problems Into Smaller Parts One of the most effective debugging techniques is reducing the problem. Suppose a regular expression fails to extract email addresses from a text document. Instead of testing it against thousands of lines, start with a few examples: [email protected] [email protected] invalid-email support@example Test each case independently. Then gradually introduce more complicated inputs. This approach helps identify whether the problem comes from: An incorrect character class Missing anchors Greedy quantifiers Incorrect escaping Unexpected whitespace Differences between regex engines The same principle applies to SQL queries, frontend rendering, API integrations, and backend logic. Smaller test cases produce clearer evidence. Use the Right Debugging Tool for the Problem Developers sometimes spend unnecessary time writing temporary scripts for tasks that can be inspected with existing utilities. Different problems require different tools. For JSON problems Use a formatter or validator to inspect malformed responses, compare nested structures, and identify syntax errors. For regular expressions Use a regex tester to examine matches, capture groups, flags, and edge cases. For Base64 data Use an encoder or decoder when inspecting encoded text or working with binary data represented as strings. Remember that Base64 is encoding, not encryption. Never treat encoded credentials or sensitive information as protected. For SQL performance Use execution plans to understand how the database executes a query. Look for expensive scans, inefficient joins, missing indexes, and unexpectedly high row estimates. Fo...

Powered by Readybot.io

A Smarter, More Systematic Debugging Workflow

Fix Docker Push to a Missing ECR Repository

DEV Community

Docker push to ECR repository does not exist

Docker push to ECR repository does not exist means the registry accepted your credentials and then found nothing to push into, so create the repository first: Amazon ECR only makes one during a push when a repository creation template matches the name. The login is not the problem, which is why the fix is in your infrastructure rather than in your workflow credentials. ECR creates a repository during a push only when a creation template matches the name. Otherwise the repository has to exist before the push starts. What this error means The login step passes, the layers start uploading or fail immediately, and the push ends on a "name unknown" error that names the repository and the registry id. The registry id is your AWS account number and the host carries the region, so the message is telling you exactly where it looked. It is deterministic: the same push fails the same way until a repository exists at that name, in that account, in that region. We have not reproduced this one on a runner, because a real push needs AWS credentials and an account we are not going to put in a public page, so the log below is the shape ECR prints rather than a recorded run. Everything else on this page is quoted from the AWS documentation, read on 2026-09-20. ```The shape ECR prints on push (illustrative, not a recorded run) The push refers to repository [123456789012.dkr.ecr.us-east-1.amazonaws.com/api] name unknown: The repository with name 'api' does not exist in the registry with id '123456789012'

Common causes

The repository was never created

The first deploy of a new service, or a service renamed in the workflow and nowhere else. Everything up to the push works, which is what makes it confusing: the credentials are valid, the image built, and the registry is real. Only the repository is missing.

The push is pointed at the wrong region or account

A copied workflow keeps a region, a role change moves the account, or a matrix deploys to two regions from one reference. The repository exists, just not where the push looked. The registry id in the error is the account it actually reached.

A creation template exists and its prefix does not match

A template set up for prod covers repositories beginning with prod/ and nothing else, so a push to staging/api gets no repository and this error. In our experience this is the surprising one, because the team knows create-on-push is configured and does not know it is scoped by prefix.

The job can push but cannot create

A pipeline written to create the repository on demand fails at the create call instead, with an access error rather than this one, when its role carries only the documented push permissions. The AWS push policy grants the layer and image actions and the authorization token, not repository creation.

How to fix it

Create the repository before the first push

  1. Create it once with aws ecr create-repository in the correct region, or in your infrastructure tool.
  2. Confirm it from the job with aws ecr describe-repositories and the name.
  3. Keep the name in one variable that both the tag and the create call read.

```Terminal
aws ecr create-repository --repository-name api --region us-east-1
aws ecr describe-repositories --repository-names api --region us-east-1 \
- -query "repositories[0].repositoryUri" --output text
Add a repository creation template if you want create-on-push Define the template with the prefix your services use and CREATE_ON_PUSH among its applied-for actions, so the first push of a new service makes the repository with the settings you chose. Use ROOT as the prefix to cover every repository that has no more specific template. aws ecr create-repository-creation-template \
- -prefix prod \
- -applied-for CREATE_ON_PUSH \
- -image-tag-mutability MUTABLE \
- -region us-east-1
Give the job the permission the fix needs The documented push policy covers uploading layers and putting an image. A job that creates reposit...

Powered by Readybot.io

Fix Docker Push to a Missing ECR Repository

Metal Sandbox: Safer GPU Coding on Apple Silicon

DEV Community

Metal Sandbox: Isolated Execution and Command Scheduling for GPU Coding Agents on Apple Silicon

Agents that generate GPU kernels need to compile, test, and iterate on Metal code without monopolizing the host GPU or crashing when concurrent sessions compete for command queues. Metal Sandbox addresses this by isolating file workspaces, scheduling command execution across a pool of Apple Silicon nodes, and migrating eligible commands to idle machines when local capacity is saturated. The paper (arXiv 2611.17294v1) reports 1.68× to 2.05× command throughput gains on four Mac mini M4 nodes under concentrated demand, and 22.3% reductions in batch elapsed time when dynamic scheduling replaces static assignment. The Problem: GPU Resource Contention in Agent Loops A typical GPU coding agent alternates between three phases: Model inference to generate candidate kernel code. Metal compilation via xcrun metal or similar toolchain commands. Kernel execution to measure performance or correctness. Each phase touches the GPU differently. Inference saturates compute units. Compilation spawns CPU-bound toolchain processes but may trigger shader validation on the GPU. Execution submits command buffers that block until the GPU finishes. When multiple agents share one Mac, naive scheduling leads to: Queue head-of-line blocking: a long compilation stalls all other agents. GPU state pollution: a crashed kernel can leave the Metal driver in an undefined state. Workspace collisions: agents overwrite each other's intermediate .metallib files or test harnesses. Architecture: Per-Instance Isolation and Cross-Node Scheduling Metal Sandbox provides three layers: 1. Workspace Isolation Each agent session gets a private directory tree: /sandbox/agent-/
src/ # generated .metal files
build/ # compiled .metallib artifacts
test/ # execution harnesses
logs/ # stdout/stderr from commands
File access is restricted via macOS sandbox profiles. An agent cannot read or write outside its assigned prefix. This prevents one session from corrupting another's build artifacts or leaking intermediate results. 2. Command-Level Scheduling Commands fall into two categories: Parallel: compilation, static analysis, or any CPU-bound task that does not require exclusive GPU access. Serial: kernel execution that submits Metal command buffers and waits for GPU completion. The scheduler maintains one serial execution slot per node. Parallel commands run concurrently up to a configurable limit (typically matching CPU core count). When a serial command arrives and the local slot is occupied, the scheduler can: Queue it locally and wait. Migrate it to another node with an idle serial slot. Migration copies the agent's workspace snapshot to the remote node, executes the command, and returns results (exit code, stdout, stderr, modified files) to the originating agent. 3. Harbor Integration Harbor is the workflow orchestration layer. It: Accepts agent requests (tool calls) and routes them to the scheduler. Tracks command dependencies (e.g., execution depends on successful compilation). Collects rollout data: command durations, GPU utilization, error rates. Triggers automatic verification (unit tests, performance benchmarks) after each kernel generation. Harbor exposes a REST API. Agents submit commands as JSON payloads: {
"agent_id": "uuid",
"command": "xcrun metal -o kernel.metallib kernel.metal",
"type": "parallel",
"workspace": "/sandbox/agent-uuid"
}
The scheduler returns a handle. The agent polls or subscribes to a webhook for completion. Scheduling Primitives and Migration Logic The scheduler uses a two-level queue: Queue Type Scope Policy Local Per-node FIFO for serial, concurrent for parallel Global Cross-node Work-stealing for eligible commands Eligibility for migration: a command can migrate if: It has no local file dependencies beyond its workspace snapshot. The workspace size is below a threshold (default 100 MB). The target node has an idle serial slot or lower parallel load. Migration cost model: the scheduler est...

Powered by Readybot.io

Metal Sandbox: Safer GPU Coding on Apple Silicon

USDT on Tron: The Real Cost of TRC-20 Sweeps

DEV Community

USDT on Tron and the energy bill: what sweeping TRC-20 deposits really costs

If you take stablecoins, a lot of your customers will want to pay in USDT on Tron. Transfers are cheap for them and most exchanges support withdrawals on it. Then you build the part that moves those deposits somewhere safe, and you find out the cheap part was only cheap for the sender. This post is about that second step: getting USDT out of per-customer deposit addresses and into a wallet you control, and why the cost of doing it on Tron behaves differently from what you might expect if you've only done this on EVM chains. Two resources, not one gas price On Ethereum-style chains you think in gas: a transaction uses some units, you pay a price per unit, done. Tron splits the cost into two resources: Bandwidth, which pays for the bytes of the transaction. Every account gets a small free daily allowance, and a plain TRX transfer usually fits inside it. Energy, which pays for running smart contract code. A USDT transfer is a call to the TRC-20 contract, so it needs energy, and quite a lot of it compared with a simple transfer. If the account sending the transaction doesn't have enough energy, the network burns TRX from that account to cover the shortfall. That's the bit that surprises people. The fee isn't a fixed number you can read off a block explorer once and hard-code; it depends on how much energy the sender already has and on the network's current energy price. You can get energy three ways: burn TRX each time, stake (freeze) TRX to receive energy that regenerates, or rent it from someone who has staked. Renting is often the cheapest option for a business that sweeps irregularly, because you don't have to lock up capital to stake. Why sweeps make this worse A checkout that gives every customer their own deposit address is the right design. It makes payments easy to match and stops one customer's payment being confused with another's. But it means money lands in many small places, and every one of them needs a contract call to move. Some rough intuition, without pretending to exact numbers that change week to week: Sweeping a deposit costs about the same whether it holds $5 or $5,000. The energy is spent on the contract call, not on the amount. So the fee as a share of the amount is brutal for small deposits and close to irrelevant for large ones. If you sweep every deposit as soon as it confirms, you pay the full cost on every small order. The usual answer is the same one you'd use on any chain: don't sweep immediately, sweep when it's worth it. Let deposits sit until the value justifies the cost, set a cap on what you're willing to pay, and batch the work. What the sweeper needs to decide When I sketch a sweep job on paper it ends up with four questions: Is there enough on this address to bother? A per-network minimum, expressed in dollars, not token units. What will it cost right now? Estimate energy and bandwidth, then price any shortfall. Is that under my cap? A ceiling per sweep, so a spike in energy prices pauses sweeping instead of eating the margin. Where does the energy come from? Burn, use staked energy, or rent. The fourth question is the Tron-specific one. On EVM chains the gas has to come from somewhere too, usually a small hot wallet that tops up deposit addresses, but there's no rental market to think about. Keep the hot wallet small and boring Whatever pays for sweeps is a hot wallet: its key has to be available to an automated process. That's a risk you want to shrink, not eliminate by pretending it doesn't exist. A few rules that hold up: The hot wallet only ever holds fuel. TRX for energy and bandwidth, ETH or the native coin for gas. Never customer funds. Only the process that sweeps (and, if you have one, the one that pays out) can unlock it. The web-facing API shouldn't be able to. Keep it encrypted at rest behind a passphrase, and keep the balance low enough that losing it would be annoying rather than serious. Alert when it runs low. A sweeper that silently stops because it ran out of TRX is a ...

Powered by Readybot.io

USDT on Tron: The Real Cost of TRC-20 Sweeps

A2UI Protocol: Secure Streaming UI for AI Agents

DEV Community

A2UI Protocol: How Agents Stream Layout Data Instead of HTML to Native UI Components

Most agent UIs stream markdown or generate HTML strings. A2UI streams layout data that native framework adapters translate into platform components. The agent emits structured events describing buttons, cards, and forms. The client renders them using React, Flutter, SwiftUI, or Jetpack Compose without a WebView or eval(). This separation creates strict capability boundaries. The agent cannot inject arbitrary code. It composes from a fixed catalog of components defined by the application. The protocol is event-based and optimized for low-latency streaming, making it viable for real-time agent interactions across web and mobile platforms. Why Layout Data Instead of Code Generative UI typically means an LLM writes JSX or HTML, then the client renders it. This works for demos but creates three production problems: Security boundary: Executing agent-generated code requires sandboxing or trusted execution contexts. Cross-platform cost: An agent that generates React code cannot target Flutter or SwiftUI without retraining or prompt engineering. Visual consistency: Generated code may not respect design systems, accessibility rules, or platform conventions. A2UI solves this by treating UI as data. The agent outputs a schema-validated stream of layout primitives. The client maps those primitives to native components. The agent never sees platform-specific rendering logic. The client never executes agent-generated code. This is the same separation used in server-driven UI frameworks like Litho or Epoxy, but extended to agent-generated content. Protocol Shape A2UI uses an event-based protocol. The agent emits a stream of JSON events. Each event describes a UI operation: adding a component, updating state, or signaling completion. Core Event Types Event Type Purpose Payload component_add Append a component to the layout tree Component type, props, parent ID component_update Modify existing component props Component ID, updated props state_sync Synchronize application state State key, value stream_end Signal completion of the UI stream Optional metadata The agent sends these events over HTTP streaming, WebSocket, or server-sent events. The client maintains a layout tree and applies events incrementally. Example Wire Format JSONL format (one JSON object per line): {"type": "component_add", "id": "card-1", "component": "Card", "props": {"title": "Flight Options", "variant": "elevated"}, "parent": "root"}
{"type": "component_add", "id": "button-1", "component": "Button", "props": {"label": "Book Now", "action": "submit_booking"}, "parent": "card-1"}
{"type": "stream_end"}
The client receives these events, validates them against the component catalog schema, and renders them using the native framework adapter. Component Catalog and Capability Boundaries The application defines a component catalog. This is a schema that lists available components and their props. The agent can only compose from this catalog. If the agent references an undefined component or passes invalid props, the client rejects the event. This enforces capability boundaries at the protocol level. The agent cannot: Render arbitrary HTML or execute JavaScript Access components outside the catalog Bypass validation rules defined in the schema The catalog is versioned. Agents and clients negotiate protocol versions during handshake. This allows safe evolution of the component library without breaking existing agents. Sample Catalog Schema const catalog = {
components: {
Card: {
props: {
title: { type: 'string', required: true },
variant: { type: 'enum', values: ['flat', 'elevated'] }
}
},
Button: {
props: {
label: { type: 'string', required: true },
action: { type: 'string', required: true },
disabled: { type: 'boolean', default: false }
}
}
}
};
The agent SDK validates outgoing events against this schema before transmission. The client validates incoming events before rendering. Both sides ...

Powered by Readybot.io

A2UI Protocol: Secure Streaming UI for AI Agents

Fix Docker BuildKit Canceled Errors in CI

DEV Community

Docker failed to solve: rpc error: code = Canceled in CI

Docker failed to solve: rpc error: code = Canceled is not a fault report. It is BuildKit relaying that the call carrying your build was canceled, in wording that comes from gRPC and from the Go standard library rather than from Docker, and the only useful question is which program did the canceling. The words "rpc error: code = Canceled desc =" are formatted by gRPC and "context canceled" by the Go standard library. Only "failed to solve" belongs to Docker tooling. What this error means A build that was making progress stops partway. One step shows as CANCELED rather than as an error, and the job ends with a solve failure carrying a gRPC code and the words context canceled. No step reported a problem of its own, and rerunning the same commit frequently succeeds. The block below is assembled from the strings each program formats, not captured from a job. ```Reconstructed from the formatting in buildx, the BuildKit client, gRPC and Go context 14 [build 5/7] RUN go build ./... 14 CANCELED ERROR: failed to solve: rpc error: code = Canceled desc = context canceled

Common causes

The job hit its timeout

The simplest cause and the easiest to confirm, because the job duration will sit right on the configured limit. Note that a job with no timeout-minutes still has a platform limit, so an unset timeout is not the same as no timeout. A build that grew past its budget produces this line every time rather than intermittently.

A concurrency group canceled the run

With cancel in progress set, a new push cancels the previous run for the same group, and every job in it stops wherever it was. This presents as intermittent failures that correlate with how often people push, which is a pattern worth recognizing because it looks like flakiness and is not. The run page says the run was canceled.

The builder or the runner went away underneath the build

A builder container killed for memory, a runner reclaimed, or a self hosted machine restarting all take down the far end. Whether you get a cancellation or a status failure depends on the order in which things tear down, which is why this cause appears on two pages. If the run page shows failure rather than cancellation, this is the branch you are on.

buildx canceled its own solve after the stream went quiet

The client cancels a solve that is already failing once its status stream has been inactive for a few seconds, so the command exits rather than hanging. That converts a different underlying problem into a Canceled line. Treat a cancellation with no timeout and no cancel in progress rule as a pointer to look for what was going wrong before it.

How to fix it

Look at the run page before you look at the build

  1. If the run is marked canceled, the cause is outside the build and the build log has nothing more to give you.
  2. Compare the job duration to timeout-minutes. Equal means the timeout, not the build.
  3. If the run is marked failed and nothing canceled it, treat the line as a symptom and look at the last step that made progress.

Scope the concurrency group so unrelated work does not cancel your builds

A group keyed only on the workflow cancels across branches and across unrelated pull requests. Keying it on the ref as well means a push cancels only its own previous run, which is almost always what people meant.

```.github/workflows/build.yml
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
Make the build finish comfortably inside its budget Raising the timeout is the fix only when the build is genuinely that long. Otherwise the cheaper move is to stop redoing work: a registry or GitHub Actions cache on the build turns a cold build into a warm one and usually moves the duration far enough from the limit that the cause stops mattering. - uses: docker/build-push-action@v7
with:
context: .
cache-from: type=gha
cache-to: type=gha,mode=max
Keep the step that tells you where it stopped Plain...

Powered by Readybot.io

Fix Docker BuildKit Canceled Errors in CI

How to Display Arabic Unicode Text in HTML and CSS

DEV Community

How to Handle Arabic Unicode Text in HTML and CSS

Introduction Arabic text can be challenging to display correctly on websites, especially when it contains decorative symbols, diacritics, or a mixture of Arabic and English characters. Fortunately, HTML, CSS, and Unicode provide the tools developers need to handle Arabic typography properly. In this tutorial, we'll explore practical examples of displaying Arabic text, managing right-to-left layouts, and avoiding common Unicode mistakes. 1. Understanding Arabic Unicode Unicode assigns code points to characters from writing systems around the world. Some Arabic examples include: ا — U+0627 (Arabic Letter Alef) ب — U+0628 (Arabic Letter Beh) م — U+0645 (Arabic Letter Meem) َ — U+064E (Arabic Fatha) Unicode characters are not images. They are text that browsers render using available fonts. 2. Setting Up HTML for Arabic Start with a basic HTML document: <!DOCTYPE html>

Arabic Text Example

مرحبا بالعالم

هذا مثال على نص عربي.

Three important settings are used here: charset="UTF-8" enables proper interpretation of Unicode text. lang="ar" identifies the document language. dir="rtl" specifies right-to-left text direction. Without correct direction settings, mixed-language content may appear confusing. 3. Styling Arabic Text With CSS Arabic typography benefits from readable fonts and comfortable line spacing. .arabic-content {
font-family: "Noto Naskh Arabic", Tahoma, sans-serif;
font-size: 20px;
line-height: 1.9;
direction: rtl;
text-align: start;
}
This example provides a font fallback and allows the text to follow its natural reading direction. Remember that a font must actually be available or loaded for the browser to use it. 4. Mixing Arabic and English Text Mixing left-to-right and right-to-left languages can cause punctuation and numbers to appear in unexpected positions. HTML provides the element to isolate text whose direction may differ from surrounding content.


Username: محمد ★


The element is particularly useful when displaying user-generated names. Developers can also use dir="auto" when the direction of text is unknown. 5. Working With Decorative Arabic Symbols Arabic names can be decorated using Unicode characters. Examples: Normal text: محمد Decorated text: ★ محمد ★ 『محمد』 مُحَمَّد These examples combine ordinary Arabic letters with symbols or diacritics. Developers should remember that visual appearance depends on font support and platform compatibility. If you want to experiment with copy-ready examples, the ZakhrafAsmaHub Arabic Decoration Tool provides Arabic text decoration options that can be tested in different applications. 6. Handling Invisible Unicode Characters Some Unicode characters are not visibly rendered. Examples include: U+200B — Zero Width Space U+200C — Zero Width Non-Joiner U+200D — Zero Width Joiner These characters serve different text-processing purposes. For example, the Zero Width Non-Joiner can prevent joining between characters in certain writing systems. However, inserting invisible characters unnecessarily may create accessibility and debugging 7. JavaScript Unicode Example JavaScript supports Unicode strings directly. const arabicName = "محمد";

console.log(arabicName);
console.log([...arabicName].length);
The spread operator counts Unicode code points, but not necessarily user-perceived characters. For more accurate character segmentation, developers can use Intl.Segmenter. 8. Common Mistakes to Avoid Incorrect encoding: Always use UTF-8. Missing RTL direction: Use dir="rtl" for Arabic content. Unsupported symbols: Test decorative text across platforms. Excessive invisible characters: Avoid unnecessary characters that may cause display issues. Poor accessibility: Keep Arabic text readable. Conclusion Unicode plays an important role in modern Ar...

Powered by Readybot.io

How to Display Arabic Unicode Text in HTML and CSS