标签：#EV

[v0.3.0] - 2026-06-29 🚀 Added Checkpoint Mechanism — ReActCore introduces three checkpoints during streaming: content_ended (after text content), before_tool_calls (before tool calls), and after_tool_calls (after tool calls), enabling precise interception and state synchronization of the execution flow. Message Queue System — Added a new MessageQueue class in run.py , supporting async enqueue, drain, and remove operations. Users can now queue messages while the LLM is running; queued messages are sent automatically after the current task completes. The frontend introduces a QueueBar component to display queued messages, with CSS spinning animation, single-line ellipsis, and hover-to-delete functionality. Queue Message Merging — MessageQueue.drain_all() now merges consecutive messages with the same name into a single message, preventing fragmented user input when multiple queue entries share the same sender. Queue WebSocket Events — The execution event protocol introduces three new event types: message_queued , queue_drained , and queue_returned ( useRunWebSocket.ts ). The frontend processes queue state updates in real time. Stop & Queue Integration — When the user clicks Stop, pending queued messages are returned to the input box via queue_returned . Checkpoint stops cleanly clear the queue and automatically start the next message. System Notification Messages — Introduced the SystemMessage type (with notification role) to separate error messages from assistant content. Errors are now rendered as independent notification bubbles, no longer embedded within assistant message cards. tiktoken Real-Time Token Estimation — ReActCore initializes a tiktoken encoder on startup for real-time token counting during streaming. Unknown models fall back to o200k_base . 🔧 Improved Custom Model Name Auto-Complete — The model name field in ModelManager has been upgraded from Select to AutoComplete , allowing users to type custom model names not in the predefined list. Message Block T

I built this project as an entry for the H0: Hack the Zero Stack with Vercel v0 and AWS Databases Hackathon. #H0Hackathon Inspiration Justice moves slowly. I learned that firsthand as my family navigated a legal dispute. What struck me wasn't just the stress — it was that things were quite disorganised. Documents were paper-based or buried somewhere in emails. Updates came through WhatsApp messages. Simple documents took a really long time to draft and send. The system was fragmented and difficult to navigate. Companies like Harvey tackle document drafting well, but legal research tools and LLM wrappers can hallucinate case law, citing judgments that don't exist. I knew that if I was going to build something for this space, it had to be grounded in real, verifiable law. That led me to Laws Africa, which provides structured access to actual South African legislation and court judgments. I also noticed a problem that lawyers experience daily: the mechanical work. Logging into court portals to file a case. Hunting through OneDrive, Google Drive, and Dropbox for the right version of a document. Sifting through hundreds of emails to find something relevant to a matter. Onboarding a new client when the intake form is a PDF someone emails you. These are not AI problems. They are automation problems — and lawyers or their secretaries are doing them manually every single day. That became Agently. What Agently Does Agently is a legal workspace that handles the full lifecycle of a matter, from the moment a client submits an intake form to the day the case closes. Matter Management. Every client engagement lives in a structured matter. Documents, emails, notes, contacts, workflows, and AI conversations are all scoped to it. A lawyer can open a matter and immediately see everything relevant. AI Agent with Real Legal Research. The AI connects to Laws Africa's knowledge bases — South African legislation, court judgments, and municipal law — so research is grounded in actual legal

Xgimi, the Chinese company known for its all-in-one smart projectors, is expanding its portfolio with a new line of screen-equipped smart glasses that first debuted at CES 2026. Unlike AR glasses from companies like Meta and Snap, Xgimi’s new privacy-focused MemoMind One skip cameras for a lighter and more discreet design that helps hide their […]

Target built a generative AI system to improve marketing campaign forecasting by retrieving and ranking similar historical campaigns. Using embeddings, vector search, and LLM ranking, it replaces rule-based workflows. Evaluation shows 75% top-1 and 100% top-3 coverage. The system reduces manual effort, improves consistency, and uses feedback loops to refine retrieval using campaign outcomes. By Leela Kumili

You finally get the response. The CV cleared whatever filter it was up against, and now there is a calendar invite for a thirty or forty five minute call. Most developers treat this as the technical screen and prepare accordingly. They load up on system design questions, leetcode style problems, or deep dives into the stack listed in the job post. What actually happens in that first call is often lighter on code and heavier on whether the person on the other side can picture working with you week after week. The engineering lead or hiring manager is trying to answer a few practical questions the CV could not fully settle. Can this person explain their decisions without needing constant context? Do they push back on unclear requirements in a way that moves the conversation forward instead of creating friction? Do they already understand how remote contractor work tends to flow, or will every interaction need extra translation? The candidates who lose ground here rarely fail on raw technical ability. They lose it on rhythm and assumptions. Some over-prepare the technical side and under-prepare the part where they need to show how they handle ambiguity. Others treat every question as an interview question that demands a polished answer, when what the lead wanted was a working conversation. The call ends with a quiet sense that this person will need more hand-holding than the role allows. Timezone and async signals are another place people slip. When a candidate spends the call reassuring the other person that they can work US hours or that they are always available for meetings, it often lands as uncertainty. The reassurance backfires. Teams that hire contractors remotely have already accepted some timezone spread. What they want to hear is how you have made async work in the past, what you leave behind when you log off, and how you keep momentum without daily syncs. The calls that move forward feel like two people working a problem together. The candidate is not sitti

Most of the time, when I need to inspect a complex JSON payload, I copy the raw string from my terminal or network tab, open a browser tab, and paste it into one of the many "JSON Formatter" sites that clutter the first page of Google. It’s a ritual we all do. We paste, we click "Format," and we wait. For small payloads, this is fine. But when you are debugging a massive API response, a deeply nested configuration file, or a large dataset, that ritual breaks down. The browser freezes. The site asks you to upload a file. Worse, many of these tools send your data to a server for processing. If that JSON contains API keys, user PII, or internal schema definitions, you are essentially trusting a third-party service with your proprietary data every time you hit "pretty print." I got tired of the latency and the privacy overhead. So I built JSONForge . The core premise is simple: do everything locally. No server-side processing. No file uploads. No network requests for the core logic. Everything happens in your browser, powered by WebGPU for heavy lifting and a small model that runs in your browser for schema inference. The WebGPU Advantage JSON parsing is computationally cheap for a modern CPU, but rendering and diffing large structures is not. When you have a 5MB JSON file, the DOM manipulation required to display it as a tree view can cause significant jank. By offloading the parsing and formatting logic to the GPU via WebGPU, JSONForge handles massive payloads without blocking the main thread. You can open a file, click "Pretty Print," and see the result instantly, even if the file is hundreds of kilobytes or larger. The UI remains responsive because the heavy computation is parallelized on the graphics card. This also means the tool works offline. If you are on a plane, or your internet drops in the middle of a debugging session, your toolkit doesn’t vanish. You can continue to diff, validate, and format without interruption. Schema Generation Without the Server Roun

Flipper Devices, a company that built a banned hacking device, now wants to hack your attention span.

Flipper Device's new Busy Bar will retail for $249.

We’ve all been there. You scroll through your feeds, see a flashy ad promising a high-paying tech job in 3 months, and think, “This is it. This is my golden ticket.” You buy the bootcamp, spend sleepless nights watching lectures, stack up a dozen colorful certificates on your LinkedIn, and then... nothing. No callbacks. No interviews. Just a lingering feeling of frustration and the nagging thought: Are bootcamps and online courses just a massive scam? I used to think so. When I was trying to break into tech, I bought courses like crazy. I collected certificates like they were Pokémon cards. Yet, my first real developer job didn't show up until five or six years later. And let me tell you a secret: it wasn’t the certificates that got me the job. It was because I finally figured out how to actually learn. The truth is, almost every bootcamp or course—even the mediocre ones—has something valuable to offer. The problem isn’t always the material; it’s how we interact with it. If you feel stuck in "tutorial hell," here is a positive, practical guide to changing your approach, reclaiming your time, and turning any learning material into real, career-changing expertise. 1. Curate Your Sources (Choose Your Battles Wisely) Before we talk about how to study, we need to talk about what to study. Even though you can extract value from almost any course, your time is highly valuable. Don't waste it on low-quality content. When choosing a course or bootcamp, look for these four green flags: The Instructor Has Real-World Mileage: Is the instructor a practitioner, or are they just reading the official documentation back to you? If they don't work with the technology daily, they won’t be able to explain the nuances, edge cases, and real-world trade-offs. A Project-First Curriculum: Avoid courses that are just endless lectures of "theory first, practice never." Look for curriculums that build actual applications. Good Pacing and Editing: We've all watched those tutorials where the ins

We’ve all been there. You scroll through your feeds, see a flashy ad promising a high-paying tech job in 3 months, and think, “This is it. This is my golden ticket.” You buy the bootcamp, spend sleepless nights watching lectures, stack up a dozen colorful certificates on your LinkedIn, and then... nothing. No callbacks. No interviews. Just a lingering feeling of frustration and the nagging thought: Are bootcamps and online courses just a massive scam? I used to think so. When I was trying to break into tech, I bought courses like crazy. I collected certificates like they were Pokémon cards. Yet, my first real developer job didn't show up until five or six years later. And let me tell you a secret: it wasn’t the certificates that got me the job. It was because I finally figured out how to actually learn. The truth is, almost every bootcamp or course—even the mediocre ones—has something valuable to offer. The problem isn’t always the material; it’s how we interact with it. If you feel stuck in "tutorial hell," here is a positive, practical guide to changing your approach, reclaiming your time, and turning any learning material into real, career-changing expertise. 1. Curate Your Sources (Choose Your Battles Wisely) Before we talk about how to study, we need to talk about what to study. Even though you can extract value from almost any course, your time is highly valuable. Don't waste it on low-quality content. When choosing a course or bootcamp, look for these four green flags: The Instructor Has Real-World Mileage: Is the instructor a practitioner, or are they just reading the official documentation back to you? If they don't work with the technology daily, they won’t be able to explain the nuances, edge cases, and real-world trade-offs. A Project-First Curriculum: Avoid courses that are just endless lectures of "theory first, practice never." Look for curriculums that build actual applications. Good Pacing and Editing: We've all watched those tutorials where the ins

Force nginx to TLS 1.3 An nginx server is accepting an old TLS version, and the exam wants it locked to TLS one point three. The config lives in a ConfigMap. The catch is that editing the ConfigMap alone changes nothing. Let's do it the way the CKA expects. 🎥 Watch the video: https://www.youtube.com/watch?v=rx-77YBw99w This is a CKA Workloads & Scheduling walkthrough. Every command below is real output from a live cluster, and you can reproduce the whole thing yourself (scripts at the end). The scenario An nginx-static Deployment serves HTTPS, and its server config comes from a ConfigMap named nginx-config. Right now it allows both TLS one point two and one point three. Your task is to allow only TLS one point three, then make nginx actually use the change, so that a TLS one point two request fails. nginx-static serves HTTPS from the nginx-config ConfigMap It currently allows TLS 1.2 AND 1.3 Restrict ssl_protocols to TLS 1.3 only A TLS 1.2 request to the Service must then fail How nginx, ConfigMaps, and rolling restarts fit together Two ideas drive this. First, ssl_protocols is an allow list; leave only TLSv1.3 and nginx rejects any older handshake. Second, a ConfigMap mounted into a pod updates the file on disk, but nginx only reads ssl_protocols when it starts. So you must roll the Deployment, with kubectl rollout restart, for the new value to take effect. Inspect the current state Start by seeing what is running and what the config says. The nginx-static Deployment, its Service on port four forty three, and the nginx-config ConfigMap are all here. Grep the rendered ConfigMap for the ssl_protocols line: it lists TLSv1.2 and TLSv1.3, so old clients still get in. $ kubectl -n nginx-static get deploy,svc,configmap NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/nginx-static 1/1 1 1 17h deployment.apps/tester 1/1 1 1 17h NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/nginx-static ClusterIP 10.96.13.162 <none> 443/TCP 17h NAME DATA AGE configmap/kube-root-ca.

Erik Steiger discusses the operational pain of legacy PDF generation in regulated banking and manufacturing. He explains how transitioning from resource-heavy engines like Puppeteer and LaTeX to a serverless Rust architecture powered by Typst can drop render latencies below 2ms. He shares how applying Git and Docker concepts to template registries ensures ironclad compliance and rapid debugging. By Erik Steiger

We (at DEV and MLH) are covering AI Engineer's World Fair by printing a physical newspaper called...

With AI-powered noise reduction, an automatic speech-focusing system, and a simple, effective hearing test, it’s a shame these aids don't come with a better app.

You know what you want from a JSON document. You just don't want to memorize whether it's $[?(@.age > 18)] or $..users[?(@.active)] . Plain English in. JSONPath out. JSONPath Assistant on FormatList lets you paste JSON, describe what you need in natural language, and get a validated JSONPath expression plus the actual results — all in your browser. No account, no API key, no data sent to a server. How it works Paste your JSON — an API response, config file, or test fixture. Describe what you need — e.g. "get all user names" or "find products with tag tech". Generate — the assistant reads your JSON structure and maps your query to JSONPath. Validate & copy — the expression runs against your data immediately. Copy the path or the matched values in one click. If the first attempt returns no matches, the tool retries with a simpler variation automatically. Example queries You type Generated JSONPath Get all user names $.users[*].name Find users older than 18 $.users[?(@.age > 18)] Get names of active users $.users[?(@.active == true)].name Find products with tag tech $.products[?(@.tags.indexOf('tech') >= 0)] Get all order prices $.orders[*].price Get the first user's email $.users[0].email Get all pod names {.items[*].metadata.name} Get all pod IP addresses {.items[*].status.podIP} The tool ships with one-click examples for each of these — load one, hit Generate, and see how it works before trying your own JSON. What kinds of queries it understands Property access — "get all names", "list order prices" Numeric filters — "older than 18", "price under $10", "greater than 100" Boolean filters — "active users", "enabled devices" Tag / category searches — "with tag tech", "beauty category" Multi-condition — "both tech and mobile tags" Quantifiers — "the first user", "the last item" Kubernetes — "get all pod names", "pod IP addresses" It analyzes field names in your JSON — so users , products , orders , or whatever keys you actually have — and builds paths that match your sc

Contact Form 7 runs on millions of sites for a good reason: it's free, light, and gets out of your way. I shipped it on client sites for years. The problem isn't that CF7 is bad — it's that it answers exactly one question ("did the form submit?") and stays completely silent on the one that actually matters in production: did the notification arrive? Here's the call every developer who maintains WP sites has taken at least once: "I filled in your contact form last week and never heard back." You check. The form is fine. JavaScript fires, the success message shows, no console errors. CF7 did its job — it handed the message to wp_mail() and forgot it ever existed. There's no record the submission happened, and no log of whether the email was delivered, bounced, or quietly dropped by the host's unauthenticated sendmail. The lead is just gone, and you have nothing to debug with. The three gaps that bite in production No submissions database. CF7 sends an email and discards the data. If the email fails or lands in spam, the submission never existed. (Flamingo helps, but it's a bolt-on — separate screen, no filtering or export out of the box, not tied to your form config.) No delivery log. You can't tell whether mail was sent, rejected, or bounced. "I never got it" has no audit trail to check against. No native block. CF7 is still a shortcode — [contact-form-7 id="123"] . You can't drop it into a block template, control its layout with block spacing, or edit it inline in Gutenberg. You paste a shortcode and hope. None of these are dealbreakers for a throwaway contact form. All three are dealbreakers when a missed submission is a missed sale. Migrating without rebuilding by hand The reason most people put off switching isn't the feature gap — it's the thought of rebuilding every form field by field. That's the part I wanted to skip. The migration path I use reads CF7's stored form definitions directly and recreates them as native forms. What comes across automatically: All

An accessibility audit is not only a compliance activity. For engineering teams, it is also a quality review of how real users interact with the product. If you are preparing for a WCAG 2.2 AA audit, the biggest mistake is waiting for the auditor to tell you what information is missing. You can make the process much smoother by preparing the right workflows, accounts, test data, and remediation owners upfront. Scope the product by user flow Do not start with only a list of URLs. URLs matter, but accessibility bugs often appear inside stateful interactions: Form validation Custom dropdowns Modal dialogs Keyboard focus management Error recovery Dynamic tables Authenticated dashboards Document downloads Instead of asking, "Which pages should we test?" ask: What tasks must users be able to complete? That usually gives you a better audit scope. Prepare accounts and stable data If a workflow requires authentication, roles, or sample records, prepare them before the audit starts. Useful prep includes: Admin, standard user, and limited-role accounts Stable sample records Forms with prefilled data where needed Test payment or transaction flows if applicable Known feature flags Environment notes This avoids spending audit time debugging access problems. Confirm the standards WCAG 2.2 AA may be the target, but the report may also need to reference WCAG 2.1 AA, Section 508, EN 301 549, GIGW, or IS 17802. Engineering teams should know this early because it affects reporting language and remediation priority. Make evidence developer-friendly A useful issue should be reproducible. Good audit findings usually include: Affected URL or screen Component or selector Steps to reproduce User impact WCAG success criterion Expected behavior Screenshot or notes This helps teams move from report to ticket without guessing. Plan remediation ownership Accessibility issues do not always map cleanly to one discipline. Examples: Missing form label: engineering Confusing error copy: content and pr

Every Node.js developer has been burned by this at least once: const port = parseInt ( process . env . PORT ); // NaN if PORT is missing const db = process . env . DATABASE_URL ; // string | undefined — not safe! Your app starts fine locally, then crashes in production because someone forgot to set an env var. The error shows up 3 hours later, not at startup. The solution I built @harmand66/typesafe-env — a tiny, zero-dependency library that validates and types your environment variables at boot time. import { createEnv } from ' @harmand66/typesafe-env ' ; const env = createEnv ({ PORT : { type : ' number ' , default : 3000 }, DATABASE_URL : { type : ' string ' , required : true }, DEBUG : { type : ' boolean ' , default : false }, }); // ✅ TypeScript knows PORT is a number env . PORT + 1 // 3001 — not "30001" env . DATABASE_URL // string — guaranteed, never undefined If anything is missing or wrong, your app fails immediately at startup with a clear message: All errors at once — no more fixing them one by one. Why not Zod? Zod is great but it's 57kb and requires a lot of boilerplate for this specific use case. @harmand66/typesafe-env is zero dependencies and does one thing well. Try it npm install @harmand66/typesafe-env GitHub: https://github.com/giannielloemmanuele-lgtm/typesafe-env npm: https://www.npmjs.com/package/@harmand66/typesafe-env Would love any feedback or contributions! 🙏

The idea came from an extremely serious game of hide and seek with my cousins. We were adults, which made it ridiculous, but also strangely perfect. Someone was hiding behind a couch in plain sight, surviving only because the seeker did not look carefully enough. That made me wonder: what if looking carefully was not enough? What if the seeker could not freely look around the room? What if they could only see the world through their phone screen, while virtual obstacles blocked parts of their view? That became the core idea behind AR Hide and Seek: a local multiplayer hide and seek game where 2-5 players use the space they are already in. The hiders physically hide somewhere in the room, while the seeker views the environment through an iPhone. The phone fills the space with digital clutter, making familiar rooms harder to read. One phone. One seeker. Real hiding places. Virtual obstacles. Why LiDAR? LiDAR on iPhone Pro models gives the phone a real-time depth map of the environment, with centimeter-level understanding of the space around it. That means virtual objects can be placed in ways that respect real-world geometry: a crate can sit on the floor, a wall can align with an actual wall, and obstacles can feel like they belong in the room rather than floating on top of it. For a game where the virtual environment needs to feel like it genuinely fills the space, that difference matters immediately. Without reliable depth information, objects can drift, clip, or hover in ways that break the illusion. The tradeoff is device requirement. LiDAR is only available on iPhone Pro models, which narrows the audience. But for this game, the better AR experience was worth it. The seeker sees a version of the room cluttered with virtual obstacles. The hiders are still physically hiding behind real furniture; the phone does not make them disappear. It simply makes finding them harder. Designing the Core Loop The mechanic is simple on paper, but it took a surprising amount of tu

Today, we’re excited to launch UIAble v1.0, an open-source component library built for developers, by developers. We explored a lot of UI libraries built on Shadcn. Most of them feel nearly identical — same structure, same aesthetic, same tradeoffs. That’s what pushed us to build something different. Not another library that looks like Shadcn with a coat of paint, but a design system with its own identity and a clearer sense of what it’s actually for. Why UIAble exists After enough frontend projects, one thing becomes obvious: the same UI patterns get rebuilt again and again. Inputs. Dialogs. Tables. Alerts. Dropdowns. OTP fields. Form validation states. Not because they’re hard to build, but because most existing libraries never quite fit real project requirements. Some are too opinionated. Some pile on unnecessary abstraction. Some become rigid after initial setup. And some make simple UI unnecessarily complicated. That friction is what led to UIAble. Not to launch another oversized library, just to build a cleaner, more practical foundation for modern frontend development. What UIAble actually is UIAble is a free, open-source UI component library built with Tailwind CSS , Shadcn-style architecture , and Base UI principles . The idea is straightforward: reusable components should stay flexible, readable, and easy to maintain. Instead of pulling projects into a rigid ecosystem, UIAble gives you components you can copy directly into your codebase, edit freely, and scale without fighting the library. No lock-in. No unnecessary abstraction. No dependency trap. What makes it different in practice A few things actually matter here. You get the code. UIAble doesn’t hide logic behind layers of packaging. You see the component. You edit it. You ship it. That alone changes how teams work with UI. It’s built for real product UI, not showcase pages. A lot of UI kits look great in demos and fall apart in production. UIAble focuses on the unglamorous stuff, forms that don’t bre