标签：#ui

Having spent over 25 years in software development and managing countless Linux environments, I've accumulated a vast collection of custom bash scripts, containers, and CLI tools. Remembering their exact paths and managing them efficiently directly from the terminal is a common challenge. To solve this, I built mytuis . mytuis is a small, attractive terminal UI for managing a personal catalogue of applications. It is built with gum and plain bash, with persistent storage in a human-readable YAML file. GITHUB REPO : https://github.com/horaciod/mytuis Why mytuis? I wanted a tool that didn't require heavy dependencies or a complex setup, but still looked great and provided a smooth user experience. Here is what mytuis brings to the terminal: CRUD operations: You can create, read, update, and delete application entries from a single menu. Quick launch: Pick an app from the filterable list and it is launched immediately. It replaces the manager process via exec, meaning no extra shell window is left behind. Smart path handling: It accepts absolute paths (like /usr/bin/firefox), relative paths (./scripts/myscript.sh), tilde paths (~/bin/foo), or plain command names looked up in your $PATH (firefox). Persistent metadata: Every entry stores its name, description, absolute path, creation date, and last-used date. Friendly TUI: You get clear menus, color-coded messages, and clean borders, all powered by gum. Under the Hood: Plain Text and Standard Utils Simplicity and standard compliance were key goals. mytuis requires bash ≥ 4 and standard Unix utilities like awk, sed, grep, date, and tput. Your catalogue is stored at ~/.mytuis.yaml. Because it is a standard YAML file, it can be inspected, edited, or backed up with any text editor. It is also completely safe to sync with a dotfiles repository or version-control. To ensure data integrity, all file operations are performed atomically by rewriting the YAML file from scratch on every change, so there is no risk of leaving the fi

On the new episode of Equity, we discussed what actually prompted the administration's latest moves against Anthropic, and what this might mean for the AI ecosystem.

Network-attached storage (NAS) provides accessible shared space on your home network. After testing, these are my favorite NAS devices.

For 13 years I have worked in production at a steel-tube manufacturer. Not in an office — on the floor, with the machines, the night shifts, the handovers at 6 a.m. A few years ago I started building software in my free time. Not tutorials for their own sake — tools that solve problems I actually see every day. Why a factory worker writes code In production you learn one thing fast: it does not matter what looks good on a slide. It matters what works at shift handover. That perspective turned out to be my biggest advantage as a self-taught developer — I know the problem before I write the first line. What I have built PIPEZ — a shift & part-count PWA. Offline-capable, running on Cloudflare Workers + D1, live in production to capture shift and piece-count data that used to live on paper. A tool-management app. A multi-user client-server app with optimistic concurrency and a local AI assistant, used daily in the office to manage the lifecycle of dies in tube production. DeepCode — an agentic AI coding client. Electron + React + TypeScript, with its own tool loop, a swarm mode, and CI/tests. The project I am proudest of. Plus multi-agent systems, RAG pipelines, and n8n automations that run every day. The stack Python/FastAPI, TypeScript/React, Node, Docker, PostgreSQL + pgvector, Cloudflare Workers, MCP, computer vision. Writing in public I will be writing here about the bridge I keep coming back to: real production experience plus building with AI. If you are automating something messy and real, I would love to compare notes.

Project Log #9: My AI Agent Works on My Phone. But What About Yours? Okeke Chukwudubem Okeke Chukwudubem Okeke Chukwudubem Follow Jun 20 Project Log #9: My AI Agent Works on My Phone. But What About Yours? # ai # webdev # programming # productivity 1 reaction Add Comment 3 min read

I did the research and taste-testing to find the best greens powders worth your money. Bloom Nutrition’s Superfood Greens Powder is my tried-and-true pick.

\shadcn/ui and Material UI optimise for opposite priorities. Choose shadcn/ui to own your component code, ship a near-zero runtime, and control every pixel; choose Material UI (MUI) for breadth — 90+ components and a paid data grid — behind Google's Material Design. shadcn/ui has ~116,000 GitHub stars and ships copy-paste components; MUI has ~98,000 stars and ~7.3M weekly npm downloads. Both are MIT-licensed and free for commercial use. This guide covers the parts you only learn by shipping both: how each behaves in the Next.js App Router, the runtime cost, real theming and dark-mode code, forms, data tables, and migration mechanics. What's the real difference between shadcn/ui and Material UI? The difference is ownership, and it decides everything downstream. MUI is an npm dependency ( @mui/material ) you install and import from node_modules — you never touch the source. shadcn/ui is a copy-paste registry: you run a CLI, the component lands in your repo, and it is now your code. shadcn/ui is unstyled, built on Radix UI primitives and Tailwind CSS. MUI ships Material Design and an Emotion (CSS-in-JS) runtime. With MUI you install and import: bash npm install @mui/material @emotion/react @emotion/styled cta.tsx import Button from " @mui/material/Button " ; export function Cta () { return < Button variant = "contained" > Get started </ Button >; } With shadcn/ui the CLI copies the source into your project and you import from your own path — there is no library to upgrade or override: bash npx shadcn@latest add button cta.tsx import { Button } from " @/components/ui/button " ; export function Cta () { return < Button > Get started </ Button >; } That ownership changes how you customise. shadcn's button.tsx lives in your repo and uses class-variance-authority (cva) for variants — you add one directly: components/ui/button.tsx // components/ui/button.tsx — this file is yours const buttonVariants = cva ( " inline-flex items-center justify-center rounded-md ... " , { varia

Why I built GigVorx, a SaaS tool to help freelancers and agencies manage client briefs and invoices more professionally. Freelancers and small agencies often have one messy problem: Client details are everywhere. Some requirements come through WhatsApp. Some come through calls. Some are sent as voice notes. Some are inside Google Docs. Some are buried in old messages. At the start, this feels normal. But later, it creates problems. You forget important requirements. You ask the client the same question again. Invoices are created manually. Project details are not organised. The whole process looks less professional. That is the problem I wanted to solve with GigVorx . What is GigVorx? GigVorx is a client intake and invoicing tool for freelancers and small agencies. It helps users: Collect client requirements professionally use ready-made brief templates organise client details create professional invoices avoid scattered WhatsApp chats, calls, and docs The goal is simple: Help freelancers and agencies manage client intake and invoicing from one dashboard. Who is it for? GigVorx is mainly for: web designers developers graphic designers video editors SEO freelancers social media agencies digital marketing agencies small service businesses These people usually talk to many clients and need a better way to collect requirements before starting work. Why I built it I noticed that many freelancers lose time before the project even starts. They ask questions manually. They collect details in random chats. They create invoices separately. They do not have one organised place for client information. This makes the work slower and sometimes confusing. So I wanted to create a simple tool that gives freelancers a more professional workflow. Current status GigVorx is already live in early access. Right now, I am not focusing on making it perfect. I am focusing on getting real users' feedback and improving the product based on what freelancers actually need. What I am learning Bui

The main idea of a Carousel isn't just about moving a bunch of elements from left to right because there must be a smoothly infinite movement, this can be done by duplicating the element, but wouldn't it be a waste of time and resources to do so. So the best solution would be rather than moving the whole element, we just move each element on a time based manner, all elements will have the animation but each element will have a unique (incremented) index, by which we will delay its start, and if we made this delay negative, we will have a smooth movement without any lagging adding a will-change will make a separate compositing layer to make the animation run on gpu rather than cpu below is a demo by which, you can understand the effect You can reach me (if you had any problems with the effect): X / twitter "where I post a lot!" LinkedIn

Dolphins, sharks, turtles, and human workers are all victims of unregulated squid fishing fleets. Another news article . As usual, you can also use this squid post to talk about the security stories in the news that I haven’t covered. Blog moderation policy.

Two monitoring approaches answer two different questions. Synthetic monitoring answers "would the checkout flow work right now if someone tried it?" Real user monitoring answers "what did the checkout flow actually do for the 4,000 people who tried it today?" The first is a robot testing a path on a schedule; the second is instrumentation recording reality as it happens. Teams reach for one when they need the other, then conclude monitoring "doesn't work." The fix is understanding what each is structurally good at — and where each is blind. Synthetic monitoring: proactive, scripted, continuous Synthetic monitoring runs scripted checks against your application from the outside, on a fixed schedule. An HTTP check hits an endpoint and asserts on the response; a browser check drives a headless Chromium through a journey — log in, add to cart, pay — and asserts on what the user would see. The defining property is that it does not need real traffic. The check runs every 30 seconds whether or not anyone is using the app, from datacenters you choose, testing exactly the journeys you scripted. When a deploy breaks checkout at 3 AM, a synthetic check catches it at 3 AM — not at 9 AM when the first customer wakes up. Real user monitoring: passive, real, traffic-dependent RUM instruments your actual frontend with a JavaScript snippet that reports back what real visitors experience: page load times, Core Web Vitals (LCP, INP, CLS), JavaScript errors, the device and network and geography of every session. It is a recording of reality with perfect fidelity — these are real people, real conditions, real outcomes. The cost of that fidelity is that RUM is entirely traffic-dependent and entirely retrospective. It can only report on paths real users took, after they took them. A page nobody visited generates no RUM data. A broken deploy at 3 AM is invisible to RUM until a real user hits it and the error is recorded. The core difference, side by side Dimension Synthetic monitoring Real

Most synthetic monitoring setups fail in one of a few predictable ways. They monitor everything and alert on nothing useful. They assert on status code 200 and miss the empty response body. They run flaky browser checks that page someone at 2 AM for a problem that fixed itself by 2:01. Or they go stale — the checkout flow changed three months ago and the check has been failing-then-being-ignored ever since. These are not exotic failures. They are the default outcome of setting up synthetic monitoring without a discipline. Here is the discipline. 1. Monitor the journeys that cost money, not everything Every browser check costs compute and, more importantly, costs maintenance. A check on a path that does not matter is worse than no check — it generates noise that trains your team to ignore alerts. Rank your journeys by cost of silent failure and monitor the top of the list: Authentication — login, signup. The gate to everything else. The revenue path — checkout, upgrade, add payment method. The core product action — the one thing your product exists to do. Critical third-party handoffs — OAuth redirects, payment iframes, SSO. Leave static pages, read-only endpoints, and admin screens to cheaper uptime and API checks . A good rule: if a path breaking would not generate a support ticket or lose revenue, it does not need a browser check. 2. Assert on what the user sees, not just the status code The entire point of synthetic monitoring is catching the failure that a 200 OK hides. So your assertions have to go past the status code. // Weak: passes even when the page renders an error await page . goto ( " https://shop.example.com/checkout " ); expect ( page . url ()). toContain ( " /checkout " ); // Strong: asserts the user can actually complete the action await page . getByRole ( " button " , { name : " Pay now " }). click (); await expect ( page . getByText ( " Order confirmed " )). toBeVisible ({ timeout : 10000 , }); await expect ( page . getByTestId ( " order-number "

You already have Playwright tests. They run in CI on every pull request, they assert that login works and checkout completes, and then they stop — because CI only runs them against a branch, at merge time. The moment the code is in production, those tests go silent. A third-party script breaks checkout at 3 AM and your perfectly good test suite says nothing, because nothing triggered it. Playwright monitoring closes that gap: you take the same browser tests and run them on a schedule against production, turning your end-to-end suite into a synthetic monitoring system that watches real user journeys continuously. Prerequisites Node.js 18+ and an existing project ( npm install -D @playwright/test , then npx playwright install chromium ). A deployed production (or staging) URL to run checks against. A dedicated synthetic test account — never a real customer's credentials. A secret store for that account's credentials (GitHub Actions secrets, or your platform's equivalent). Never hard-code them. Step 1 — Write a check that asserts on what the user sees A monitor-grade check is not "did the page load." It is "could a user complete the thing they came to do." Assert on the outcome, with a generous timeout for real-world latency: import { test , expect } from " @playwright/test " ; test ( " checkout reaches confirmation " , async ({ page }) => { await page . goto ( " https://shop.example.com " ); await page . getByRole ( " button " , { name : " Add to cart " }). click (); await page . getByRole ( " link " , { name : " Checkout " }). click (); await page . getByLabel ( " Email " ). fill ( process . env . SYNTHETIC_EMAIL ! ); await page . getByLabel ( " Card number " ). fill ( " 4242424242424242 " ); await page . getByRole ( " button " , { name : " Pay now " }). click (); // The assertion a 200 OK can never make for you: await expect ( page . getByText ( " Order confirmed " )). toBeVisible ({ timeout : 15000 , }); }); Credentials come from process.env , not the source. The t

Synthetic monitoring tools all promise the same thing — catch the broken checkout before your users do — and then bill you in seven different ways for it. The hard part of choosing one is not the feature checklist; it is predicting what you will actually pay when a single browser check running every 30 seconds from three regions turns into 259,200 runs a month. We compared seven synthetic monitoring tools on what separates them in practice: browser engine and fidelity, how you author checks (code, recorder, or AI), location coverage, alerting and on-call, failure forensics, and — the one that surprises teams — the pricing model. Every price below was verified against official pricing pages in June 2026. For the concepts behind these tools, start with what synthetic monitoring is . TL;DR comparison Tool Best for Browser engine Authoring Pricing model Browser price Checkly Code-first teams running Playwright suites Chromium (+ suite) Code (TypeScript) Per-run, 3 separate bills ~$4–6.50 / 1k Datadog Enterprises that want APM correlation Chrome/FF/Edge Recorder + code Per-run × freq × locations ~$12–18 / 1k Grafana Cloud / k6 OSS-leaning teams, best free tier Chromium (k6) Code (k6) + convert Per-execution ~$50 / 10k Better Stack Bundled monitoring + on-call Chromium Code + codegen paste Per-minute + per-seat ~$1 / 100 PW-min New Relic Broad type matrix + compliance Selenium (Chrome/FF) No-code step + code Per-check + seats + ingest ~$50 / 10k Sematext Predictable per-monitor pricing Chromium Code Per-monitor / month ~$7 / browser monitor Site24x7 No-code recorder + many locations Chrome/FF Recorder Pooled "advanced checks" ~$10 / 10k runs How we evaluated Real synthetic monitoring is more than a scheduled ping, so we scored each tool on six dimensions. Browser fidelity : does it run a modern engine (Playwright/Chromium) or older Selenium, and how faithfully does it reproduce a real user? Authoring mode : can you write checks as code, record them point-and-click, or gen

Just as last week was ending, the US government forced Anthropic to pull its two newest models, Fable 5 and Mythos 5, citing national security concerns after Amazon researchers allegedly found a way to bypass Fable 5’s guardrails. Cybersecurity researchers have since signed an open letter calling the move dangerous, and Anthropic itself noted the same jailbreaks exist in other models. So is […]

We break down the current iPad lineup to help you figure out which of Apple’s tablets is best for you.

Forget about patchy internet connections and dead spots in the house. These WIRED-tested multiroom mesh systems will get you online in no time.

Even after your movies end, these art televisions look stunning on any wall.

Find the right wearable for your lifestyle, workouts, and goals.

Every startup idea looks perfect... until you start building. The first version of PixoraCloud looked amazing on paper. Then reality hit. We discovered: Some features weren't necessary Some APIs were too complicated Some ideas solved our problem, not the user's problem So we changed them. A lot. That's where we are today. Not chasing perfection. Chasing simplicity. Building in public means admitting your first idea isn't always your best one. What's one thing you've completely changed after starting a project?