The Mermaid Mask, the next point-and-click game from Tangle Tower developer SFB Games, has everything you could ask for in a great murder mystery. It starts with a compelling setup: The captain of a submarine is found dead in a locked room, his body next to a mysterious cauldron with blood trickling across the floor. […]

Write-up From r/emulation : Six months ago I got upstream Flycast compiling to WebAssembly and running as a libretro core. It booted games at about 2 FPS on the interpreter. Fun proof of concept, completely unplayable. Today, heavy 3D titles like Jet Grind Radio and Shenmue hold their target framerate at native resolution with clean audio, in a browser tab, on ordinary hardware. Here's how that gap closed. Why this wasn't supposed to work Every Dreamcast emulator that runs at full speed depends on a dynamic recompiler. A dynarec generates native code at runtime and jumps into it. WebAssembly makes that structurally impossible: code and data live in separate address spaces, so there's no writable-executable memory to generate into, and nothing you write into linear memory can ever be executed. Upstream had already declined WASM support, and the consensus was that this was a dead end. Browser Dreamcast would stay a slideshow. Fuck that. The workaround The JIT doesn't patch memory. It generates entire WebAssembly modules at runtime. SH4 code is decoded into Flycast's SHIL IR, lowered to wasm bytecode in the browser, compiled and instantiated through the wasm API, and dispatched via call_indirect from a C dispatch loop. The host boundary gets crossed once per module, at compile time. Steady-state execution is wasm calling wasm, with no JavaScript anywhere on the dispatch path. Getting from "it works" to "it's fast" Months of walls, and slightly less hair. Every one of these is documented with numbers in the writeup: Self-modifying code detection via per-page generation counters, eliminating 98% of runtime block hashing Fusing hot blocks into multi-block modules Inline fast paths for guest memory access. This was the big wall. Memory ops were crossing the wasm to JS import boundary about 500,000 times per frame. It's now about 700. A frame pacer that repays guest time instead of counting renders Compile storm management so scene transitions don't freeze An AudioWorklet r

After setting up Jenkins and creating my first Declarative Pipeline, the next step was preparing my machine to build Docker images. Since my pipeline will eventually clone code from GitHub, build a Docker image, and push it to a container registry, Jenkins needs access to Docker. Without Docker installed, the docker build stage would fail because Jenkins wouldn't be able to execute Docker commands. Installing Docker On my Ubuntu machine, I installed Docker using: sudo apt update sudo apt install docker.io -y Once the installation completed, I verified it using: docker --version This confirmed that Docker was successfully installed and ready to use. Verifying Docker Installation Installing Docker is only half the job. The next step is to check whether your current user has permission to use Docker. Run: docker ps Expected Output If everything is configured correctly, you should see something similar to: CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES Even if no containers are running, getting an empty table like the one above means Docker is working correctly. What If You Get a Permission Error? If you see an error like: permission denied while trying to connect to the Docker daemon socket it means your current user doesn't have permission to access the Docker daemon. First, check which user you're currently logged in as: whoami Example output: nishant Now add your user to the docker group: sudo usermod -aG docker $USER What does this command do? usermod modifies a user account. -aG means append the user to a supplementary group without removing existing groups. docker is the group that has permission to communicate with the Docker daemon. $USER automatically refers to your currently logged-in username. Apply the Changes The group membership won't take effect immediately. You have two options: Option 1 (Recommended): Log out of your Ubuntu session and log back in. This refreshes your user groups and is the most reliable method. Option 2: Simply restart your ter

#ai #kyc #compliance #duediligence #api #llm #fintech #rapidapi AI Writes Code. You Still Own the Verdict. ChatGPT can spin up a KYC dashboard in an afternoon. It will generate React components, SQL schemas, and swagger documentation that look production-ready. But ask it whether fintech-example.io is a legitimate payment processor or a sanctions-evasion shell, and it will confidently fabricate ownership records, misread registrar data, or hallucinate a clean bill of health. That is the gap AI cannot close on its own: grounding . Large language models reason over tokens, not truth. A reliable due-diligence or compliance tool must anchor every LLM answer in real, verifiable, timestamped data—WHOIS records, IP geolocation, company registries, email infrastructure, and sanctions lists. This article shows how to use the Portfolio Investigate API to feed your AI agents factual domain dossiers and compliance verdicts, turning a prototype into something a compliance officer can actually trust. The Hallucination Problem in Due Diligence LLMs are autocomplete engines. They predict what words should come next based on training data, not live facts. In a KYC context, that creates three failure modes: Stale knowledge — model weights freeze; a domain can change ownership next week. Fabricated citations — the model may invent registrar names or corporate addresses. Missing signals — an LLM has no built-in access to WHOIS history, IP blocks, or OFAC lists. The fix is not to abandon LLMs. It is to constrain them: give them a structured evidence packet first, then let them summarize, classify, and answer natural-language questions on top of it. That evidence packet is exactly what Portfolio Investigate API returns. What Portfolio Investigate API Delivers Portfolio Investigate API is a one-call domain investigation report. It aggregates five underlying portfolio APIs into a single dossier: WHOIS — registration dates, registrar, name servers, privacy status. IP Geolocation — where the

Reddit may still be considering ending its licensing deal with Google.

Google is expanding Gemini on two fronts at once: faster, lower-cost models for software and enterprise workflows, and a new robotics family designed for embodied, cross-robot control. The releases include Gemini 3.6 Flash , Gemini 3.5 Flash-Lite , Gemini 3.5 Flash Cyber, and Gemini Robotics 2 with related embodied-reasoning and on-device variants. The clearest immediate enterprise story is the widening choice of models for agentic work. In its official Gemini Flash announcement , Google positions 3.6 Flash as a general workhorse for coding, knowledge work, and multimodal tasks, while 3.5 Flash-Lite is aimed at workloads where response speed and cost efficiency are decisive. The robotics update extends the same broader push beyond software agents into systems that must reason about and act in physical environments. A broader Gemini stack for agentic workloads Gemini 3.6 Flash is generally available through Google's developer, enterprise, and consumer channels. Google says it improves on 3.5 Flash for coding, knowledge-work, and multimodal tasks, while producing around 17% fewer output tokens than 3.5 Flash. That token-efficiency claim matters because output tokens are a material part of both latency and inference spending in multi-step agent workflows. Google lists pricing for Gemini 3.6 Flash at $1.50 per 1 million input tokens and $7.50 per 1 million output tokens . The company describes the model as offering a lower cost per task, a metric that depends not only on token prices but also on how many tokens a task requires to complete. The supplied release information does not provide a price for 3.5 Flash-Lite, so it should not be inferred from 3.6 Flash pricing. Gemini 3.5 Flash-Lite occupies a different role. Google calls it its fastest and most cost-effective subfamily, with a stated output speed of 350 output tokens per second . It is intended for high-throughput agentic workflows where an organization may value quick model responses and high request volume ove

CompTIA PenTest+ / Ethical Hacking Certification Series Professional Reference Guide — GitHub Edition Covers: Passive Reconnaissance · OSINT · DNS · Social Media · Cryptographic Analysis · Shodan Table of Contents 3.0 Introduction 3.1 Performing Passive Reconnaissance 3.1.1 Overview 3.1.2 Active Reconnaissance vs. Passive Reconnaissance 3.1.3 The OSINT Methodology — How Professionals Think 3.1.4 OSINT Tools — The Complete Professional Arsenal 3.1.5 DNS Lookups — Deep Dive 3.1.6 DNS Reconnaissance — Advanced Techniques 3.1.7 Identification of Technical and Administrative Contacts 3.1.8 WHOIS Intelligence — Extracting Maximum Value 3.1.9 DNS Lookups — Lab-Level Practical Reference 3.1.10 Cloud vs. Self-Hosted Applications and Related Subdomains 3.1.11 Social Media Scraping 3.1.12 Employee Intelligence Gathering 3.1.13 Cryptographic Flaws 3.1.14 Finding Information from SSL Certificates 3.1.15 Company Reputation and Security Posture 3.1.16 File Metadata 3.1.17 Web Archiving, Caching, and Public Code Repositories 3.1.18 Finding Out About the Organization — Aggregation Techniques 3.1.19 Advanced Searches — Google Dorking and Beyond 3.1.20 Open-Source Intelligence (OSINT) Gathering — Frameworks and Automation 3.1.21 Shodan — The Search Engine for Everything Connected 3.1.22 Breach Data Intelligence — Leaked Credentials and Exposure Monitoring 3.0 Introduction Module Overview: Information Gathering and Vulnerability Scanning Module Objective: Perform information gathering and vulnerability scanning activities at a professional, senior-level standard. Before a single exploit is launched, before a single payload is crafted, every professional penetration tester invests significant time in a discipline that separates competent practitioners from exceptional ones: information gathering . The reconnaissance phase is the intelligence foundation upon which the entire attack strategy is built. The quality of your reconnaissance directly determines the quality of your attack. Why T

It's easy to test a site on office fibre, get a 95+ Lighthouse score, and call performance "done." Then someone in a secondary city mentions the site feels slow on their phone, and the gap between tested performance and real performance becomes obvious. This isn't a Pakistan-specific problem in theory, but it's an unusually common one in practice — a large share of real users here are on congested 3G or throttled 4G, on mid-range Android devices, often outside the main metros where infrastructure is best. If you're building for a Pakistani (or generally emerging-market) audience, "works great in the office" isn't the same as "works great for the actual user." Here's what actually moves the needle, beyond just plugging in a CDN. A CDN helps, but it doesn't fix the last mile A CDN gets your assets physically closer to the user, which helps. But if the connection between someone's phone and the nearest edge node is still a congested 3G link, the CDN's job is basically done — the bottleneck is the last mile, and no amount of edge-caching fixes that. What actually helps is reducing how much has to travel down that last mile in the first place. That reframes the whole problem: less about "getting bytes there faster" and more about "sending fewer bytes." 1. Image weight is usually the biggest offender Images are typically the single largest contributor to page weight, and the fix isn't exotic: // Next.js example — explicit width/height prevents layout shift, // and the Image component serves modern formats automatically import Image from " next/image " ; < Image src = "/hero.jpg" alt = "Product hero shot" width = { 1200 } height = { 630 } priority // only for above-the-fold images /> A few concrete habits that add up: Serve WebP/AVIF instead of raw JPEG/PNG where you can — usually 25-50% smaller at equivalent visual quality Always set explicit width / height (or use a framework component that does it for you) so the browser doesn't shift layout while images load — this als

When an AI agent runs a multi-step pipeline, every step creates temporary files. Article drafts, image uploads, JSON payloads, log files. Over fifty runs, these files accumulate. Some get cleaned up, some don't. And the ones that don't cause the next run to fail in confusing ways. I hit this exact problem with my publishing pipeline. A failed cleanup from run #12 left a stale devto_article.json in the working directory. Run #13 picked it up, parsed it, and published a draft with last week's title. The logs showed "JSON loaded successfully" — which was technically true. The file was valid JSON. It just belonged to the wrong run. The fix was a Guard class that sits between the pipeline and the filesystem. Every file the pipeline creates must be registered before the pipeline starts. Any file that appears without registration halts the pipeline immediately. Run identity gets embedded into every file, so even if a cleanup fails, the next run can tell the file doesn't belong. The Problem With Temp Files Temp files are invisible by design. You create them, use them, delete them. But when deletion fails — file lock, process crash, permission error — the file becomes a ghost. It exists on disk but nobody remembers it's there. The next run scans the directory, finds the ghost, and treats it as intentional. This is especially dangerous for JSON files because they're always valid. A stale manifest.json looks identical to a fresh one. The only difference is the content, and the loader doesn't check content provenance. Here's a concrete example from my pipeline: # The naive approach — just check if the file exists def load_manifest ( path ): if not path . exists (): return None return json . loads ( path . read_text ()) This code returns valid data from any run, any day, any context. It answers "can I read this file?" but not "should I read this file?" That distinction is the entire bug. The Guard Pattern The Guard class solves this by requiring every temp file to be registered

Welcome back to the React Mastery Series . In Day 1, we introduced the roadmap of this series and discussed what we will cover — from React fundamentals to enterprise-level architecture. Today, we will start with the most important question: What is React, and why was it created? What is React? React is an open-source JavaScript library for building user interfaces , especially single-page applications (SPAs). It was created by engineers at Meta (Facebook) and was initially released in 2013. React focuses on one core idea: Build complex user interfaces by breaking them into small, reusable components. Instead of creating a complete application as one large piece of code, React encourages developers to divide the UI into independent and manageable components. Example: A banking application dashboard can be divided into: Dashboard │ ├── Header │ ├── AccountSummary │ ├── TransactionList │ ├── TransferMoneyForm │ └── Notifications Each part can be developed, tested, and maintained independently. Why Was React Created? Before React, developers commonly used traditional JavaScript and libraries like jQuery to update web pages. For small applications, this approach worked well. But as applications became larger, several challenges appeared. 1. Managing Complex UI Updates Imagine a banking application where: Account balance changes Transactions are updated Notifications appear User profile information changes With traditional DOM manipulation, developers had to manually find elements and update them. Example: document . getElementById ( " balance " ). innerHTML = " $5000 " ; As the application grew, managing thousands of DOM updates became difficult. React introduced a different approach: Describe what the UI should look like, and React manages the updates. The Problem With Direct DOM Manipulation The browser provides the Document Object Model (DOM), which represents the HTML structure. Example: HTML | DOM Tree | Browser Rendering When we update the DOM frequently: Browser

Recently I went looking for a CLI tool to manage my Dev.to articles from the terminal. I write 4-5 articles per month, track analytics obsessively, and wanted a git-backed workflow. I found 9 existing tools. Tried them all. Here's what happened: devto-cli (Node): Last commit 2 years ago. Broke on install. dev-to-git (Node): Only syncs TO local. Can't push back. slinkity : Abandoned. forem-cli : 3 endpoints implemented out of 40+. Every single tool does the same thing: publish an article. That's it. Maybe pull. Maybe validate tags. Meanwhile the Dev.to API has 40+ endpoints including analytics, semantic search, ML-powered content concepts, follower engagement, trend tracking, and reading list management. Nobody uses them. So I built devpub . Table of Contents What devpub does What I discovered in the API The build story Architecture Try it Contributing What devpub does (that nothing else does) # The basics (every tool does this) devpub push -f articles/my-post.md devpub pull # Analytics in your terminal devpub stats # Views: 246.5K | Reactions: 4.4K | Comments: 402 | Followers: 18.9K # Full dashboard with top articles devpub dashboard # AI-powered search (semantic, not keyword) devpub search "building serverless apps" --semantic # What's trending RIGHT NOW devpub trends # Catch problems before publishing devpub validate The difference isn't one feature. It's coverage. Here's the comparison: Capability devpub Everyone else Publish/update articles Yes Yes Pull articles to local Yes Some Analytics (7 endpoints) Yes No Semantic search Yes No Trend discovery Yes No Article validation Yes No Rate limiting (30 req/30s) Yes No Retry logic for failures Yes No Concepts API (ML topics) Yes No What I discovered in the Dev.to API While building devpub, I found several API endpoints that aren't documented anywhere obvious: 1. Semantic Search -- Dev.to has a full embedding-based search system using Gemini embeddings (768-dimensional vectors) with pgvector. You can search articles b

TL;DR — Fitz LiveViews is a real-time UI framework for Fitz , a compiled, gradually-typed language where HTTP, WebSockets, auth, and an ORM are part of the syntax. You write single-file components ( .fitzv ) with state / event / <template> , and the server renders HTML, diffs it, and patches the browser over a WebSocket — no JavaScript build step, no client framework . The same .fitzv can also compile to WebAssembly for offline, zero-round-trip widgets. There's a live component gallery, a course, and a full flagship app (an admin panel with auth + Postgres + Docker) already built with it. Repo : github.com/Thegreekman76/fitz-liveviews · Docs : thegreekman76.github.io/fitz-liveviews This is the first post in the FitzLiveViews series. I'll start with the pitch and the setup; the following posts build things. The problem Building a modern web UI usually means two languages, two type systems, and a build pipeline: a backend (Python / Node / Go) plus a frontend framework (React / Vue / Svelte) plus its toolchain (Vite / Webpack / Babel). You duplicate your types across the wire, you keep two mental models in sync, and node_modules grows a personality of its own. Phoenix LiveView (Elixir) showed there's another way: render on the server, push diffs over a WebSocket, and let the browser stay dumb. No client framework, no API to hand-write, no JSON serialization dance. Fitz LiveViews brings that model to Fitz — and adds a twist: the same component can also compile to WebAssembly when you want purely client-side, offline interactivity. What Fitz LiveViews looks like A component is a single .fitzv file — state, event handlers, and a template, like Vue or Svelte: component Counter { state { count : Int = 0 } event increment () { count = count + 1 } event decrement () { count = count - 1 } event reset () { count = 0 } < template > < div id = " counter-app " > < p > Count : { count } < /p > < button @ click = " increment " >+ 1 < /button > < button @ click = " decrement " >- 1 <

Originally published on tamiz.pro . The initial euphoria surrounding Large Language Models (LLMs) was largely driven by their ability to generate code. We saw demos of developers asking an LLM to write a React component, a Python data pipeline, or a SQL query, and watching it appear instantly. This capability, while impressive, is fundamentally different from the engineering challenges posed by AI Agents. A code generator is a stateless tool; an AI Agent is a stateful, autonomous entity that interacts with external systems, makes decisions, and executes actions over time. Treating an AI Agent like a code generator is the primary reason most AI projects fail to reach production. When you move from generating static artifacts to orchestrating dynamic, multi-step workflows, the complexity shifts from syntax correctness to systemic reliability. In this deep dive, we explore why production-grade AI Agents require a paradigm shift in engineering, focusing on three critical pillars: rigorous state management, comprehensive observability, and deterministic control flows. The Fundamental Shift: Stateless Generation vs. Stateful Execution To understand the engineering gap, we must first distinguish between what a code generator does and what an agent does. A Code Generator operates in a Request -> Response loop. The input is a prompt; the output is a snippet of code. The LLM does not retain memory between calls, does not modify external state (like a database), and does not decide its own next steps based on runtime errors. It is a function with high entropy. An AI Agent is a loop. It observes the environment, reasons about the next best action, executes that action (often via tools or APIs), and observes the result. This creates a feedback loop: Observe -> Think -> Act -> Observe -> Think -> ... This loop introduces several engineering complexities that static code generation does not: Non-Determinism: The agent’s path through the workflow is not fixed. It depends on the LLM

Article URL: https://freeaipromptgen.com/ Comments URL: https://news.ycombinator.com/item?id=49133672 Points: 6 # Comments: 0