Mentions

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

Mentions by source

X

6,843
Nov 16, 13:00Nov 17, 13:00

Bluesky

2,242
Nov 16, 15:00Nov 17, 15:00
Nov 16, 14:00Nov 17, 14:00
Nov 16, 14:00Nov 17, 14:00
Nov 16, 15:00Nov 17, 15:00
Nov 16, 15:00Nov 17, 15:00
Nov 16, 14:00Nov 17, 14:00
Nov 16, 16:00Nov 17, 16:00
Oct 14, 21:00Oct 15, 21:00

Delayed · data through Oct 15, 21:00 UTC

DEV

1,036
Nov 16, 15:00Nov 17, 15:00
Nov 16, 15:00Nov 17, 15:00
Nov 16, 11:00Nov 17, 11:00
Nov 16, 15:00Nov 17, 15:00
Oct 28, 01:00Oct 29, 01:00

Delayed · data through Oct 29, 01:00 UTC

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

Delayed · data through Nov 9, 11:00 UTC

Nov 16, 15:00Nov 17, 15:00

Latest posts

  1. Winget-AutoUpdate (WAU) can't auto-update UniGetUI. I've opened an issue here: UniGetUI#5662

  2. X@howtopam · 27 views

    System restore tool for Linux. Creates filesystem snapshots using rsync+hardlinks, or BTRFS snapshots. Supports scheduled snapshots, multiple backup levels, and exclude filters. Snapshots can be restored while system is running or from Live CD/USB. linuxmint/timeshift t.co

  3. X@DYoung_AI · 123 views

    Figma pricing card → layout + styles in your coding agent's context. Set up Framelink, paste the frame link, then ask: "Build this card; match spacing + type." Requires a Figma access token, file access + compatible coding client. GLips/Figma-Context-MCP

  4. X@supreme__sahil · 2 likes · 74 views

    I like how people are making linux installations easy for everyone ekimiateam/libertix

  5. X@sartoopjj · 256 likes · 27 reposts · 10,854 views

    نسخه جدید #Thefeed قابلیت لاگین به تلگرام از طریق DNS داره.اینجوری توی اینترنت داخلی هم به تلگرامتون دسترسی خواهید داشت. میتونید از کانال تلگرامم توضیحات و کانفیگ مخصوص فعال کردن این بخش رو بردارید: t.me لینک گیتهاب پروژه: sartoopjj/thefeed t.co

  6. X@Ahang1617888 · 7 views

    Keeping AI-assisted analysis reproducible? marimo saves notebooks as Python and reruns dependent cells. Its AI assistant can use dataframe context. Bring a model provider, review generated code, and use lazy mode for costly cells. marimo-team/marimo

  7. Redditu/Aware_Presentation11 · r/TechnologyThread · 11 points · 4 comments · IBM

    IBM is hacked? all repo public

  8. X@LolsShow · 36 likes · 1 repost · 1,098 views

    Source Code for Versus is up again! Now, all of the builds download from verified GitHub builds instead of his own server. Why he deleted it? - It was an old version of his repo and he just forgot to upload it again on a new one. Rlaxogus123/Geode_Versus_Mode t.co

  9. Someone built an open-source version of this, but it’s far from polished: joeblau/subvox There was this really interesting one where it reads your lips: amywork777/lipflow I’m using these to build my own so I can work in co-working spaces, planes, and libraries. Though moving my mouth with no words might draw some eyes.

  10. Location: Istanbul, Turkey (UTC+3) Remote: Yes (full EU hours or overlap with US mornings) Willing to relocate: Yes Technologies: n8n, JavaScript/Node.js, Google Apps Script, SQL (Oracle, PostgreSQL), REST APIs and webhooks, LLM APIs (Gemini, OpenAI), Git; Python (learning) Résumé/CV: on request GitHub: github.com/gamzeozgul Email: gamze.ozgul [at] hotmail.com Self-taught developer with a data background (years of SQL and Oracle BI reporting). I build tested automations and small backends: Willow & Comb, a booking system on Google Apps Script + n8n with 39 automated tests; an AI booking assistant with its own API (duplicate-safe bookings, retries, an ownership check for cancellations); merged open-source PRs to express-rate-limit, simplefeatures and dontbemichael. I also found and reported two platform bugs that the vendor's CTO fixed. Looking for junior automation, backend or QA roles, part-time contract or full-time.

  11. X@mathcuber21 · 6 views

    Tesseract OCR: renderer failures used to exit with code 0. Every script downstream believed a failed render had succeeded. Fixed and merged by the lead maintainer. Neovim. curl. Tesseract: three upstream fixes in six days. PR: tesseract#4669

  12. small but useful: @TencentAI_News split every AI-Infra-Guard scanner into its own pip package in v4.6.8. aig-mcp-scan audits mcp servers, aig-skill-scan audits agent skills, no web service needed. if you ship mcp tools, cheap check before release. Tencent/AI-Infra-Guard

  13. X@lain___os · 1 like · 23 views

    my shell and file tools have a workspace. paths that try to escape it are refused, and shell commands have a timeout. a boundary is more useful when you can find it in the code. lain-labs/os t.co

  14. X@HatforceSec · 3 views

    @RealCondha @0xSero Faster open source stack already out there Sequester-AG/ds41h

  15. Redditu/su_ble · r/selfhosted · 33 comments

    If you are using Fail2Ban-Report please read this I was contacted by security researchers and they showed some critical things to patch, this is done now, so please update your version as soon as you can to the newest version. Security advisory are made public Security Fixes & Hardening SubleXBle/Fail2Ban-Report - Fixed Stored Cross-Site Scripting (XSS) via Client Sync (0.5.1 Hotfix): Resolved a critical vulnerability in backsync.php and blocklist-overlay.js where malicious or compromised sync clients could upload a manipulated JSON file containing arbitrary JavaScript payloads (e.g., inside the ip or jail fields). The UI has been refactored to ban innerHTML usage, shifting entirely to secure textContent and createElement DOM manipulation to neutralize any script execution hazards. - Fixed Authentication Bypass on Read Plane (0.5.2): Resolved an architectural flaw where unauthenticated network sessions were automatically assigned a default viewer role, leaving sensitive firewall history, server configurations, and blocking aggregations open to anonymous actors. Access is now strictly guarded at the global gateway level. - Fixed Shell Command Injection in Helper Scripts (0.5.2): Patched manage_users.sh and manage-clients.sh where user-supplied inputs containing specific shell characters (like apostrophes) were interpreted as executable PHP program text. Data payloads are now passed securely using isolated environment variables (getenv()). - Fixed Credentials Leak in Process Table (0.5.2): Hardened the multi-server sync engine (syncback.sh and fail2ban_log2json.sh) to prevent sync passwords (CLIENT_PASS) from leaking into the host's public process listing (argv). Commands are now packaged dynamically inside localized, temporary configuration files (chmod 600). - Secured API Lookup Restrictions & Data Sanitization: Overhauled action_report-ip.php to mandate active administrator verification before reaching outbound services, preventing blind exploitation of paid lookups (AbuseIPDB / IPinfo). Integrated native IP structure enforcement (FILTER_VALIDATE_IP).

  16. X@fibanacci101 · 12 views

    Hyprland The independent, highly customizable dynamic tiling Wayland compositor that actually looks good. Still one of the most popular desktop projects on GitHub. hyprwm/Hyprland

  17. X@CodeWriter23 · 18 views

    @BrianRoemmele Did you catch this on HN yesterday? "Memdoor: A team of 5 Qwen3.8-27B models beats Fable 5 on LiveCodeBench Hard" github.com/guregodevo/memdoor/tree/main/examples/…

  18. X@fibanacci101 · 6 views

    Impeccable. The design vocabulary for your coding agent. Steer it toward polish, review with critique, and catch AI slop before it ships. pbakaus/impeccable

  19. X@NaifCubed · 12 likes · 555 views

    تخيل الايجنت يرتب الكود اللي خربطه بنفسه 🤓 ريبو مجاني اسمه desloppify
3.7K نجمة ويشتغل مع Claude Code و Cursor و Codex: 1- يطلع الكود الميت والمكرر
2- يراجع التسمية وتقسيم الملفات
3- يصلح المشاكل وحدة وحدة peteromallet/desloppify احفظها 🦦

  20. X@xinwei_97 · 9 views

    You can't improve what you can't see. The more autonomous agents get, the more tracing matters: what it did, why, where it went wrong. That's what we're building at @TracerootAI, and agent tracing is the part that resonated with me most. It's open source: traceroot-ai/traceroot

  21. X@chinmay_jain_ · 1 like · 37 views

    I use Git daily and had no idea how it works. So I'm building my own, from scratch, in TypeScript + Bun. 🛠️ It's called Gitty. 27 commits in, and I've already lost hours to bugs I'm too embarrassed to explain. Documenting the whole journey here -> CHINMAYJAI/Gitty t.co

  22. If OXR helps you, consider giving it a ⭐ on GitHub. SoMarkAI/OXR

  23. X@fibanacci101 · 17 views

    Hallmark. Anti-AI-slop design skill for Claude Code, Cursor, and Codex. Stops your agents from shipping generic, low-taste UI. Nutlope/hallmark

  24. From a GraphQL monorepo to FastAPI and React: the coupling changed Language Power is a vocabulary trainer I've built three times. The current version is a Python backend, FastAPI with PostgreSQL and Redis, and a React client, kept in two separate repositories and talking over REST. It runs as a private deployment I use every day and a public demo with strict limits. The version before it was a TypeScript monorepo with a GraphQL API and a shared schema. I built the app for my own language learning, so what follows is about maintaining one developer's project over several years, not about a team or about traffic. Between the two versions I changed more than the repository layout: the language, the API style, the database, authentication and the deployment. So this isn't a controlled comparison of monorepos and separate repositories. It's an account of which dependency caused each cost, and what changed when that dependency went away. v2: a monorepo while the app was taking shape Version 2 ran from 2022 to 2025 (language-power-v2). It was a Yarn workspaces + Lerna monorepo with four packages: | Package | What it held | | --- | --- | | server | Apollo Server 4 on Express, MongoDB | | front | React 18 + Apollo Client, built with Webpack 5 | | ui | The design system and the game components, documented in Storybook | | shared | The GraphQL schema, as .graphql files | I chose GraphQL because I planned to use the app while travelling and wanted each screen to ask for only the fields it needed. The monorepo followed from that: one schema, and every package generating its TypeScript types from it. The server, the front and the design system each have their own codegen config pointing at the same folder (server, front, ui): schema: '../shared/schema', During those years I was still working out what the app should be. I added games, rewrote the spaced-repetition scheduler, added Spanish with its verb conjugations and noun genders, and tried features I later dropped, such as tags and a speaking game. The schema changed often. What the monorepo bought - Schema changes surfaced early. Codegen fails when a query in front asks for a field the schema no longer has, and the regenerated types turn stale field names into type errors. This was early feedback, not a guarantee: the production builds skip type checking (tsc --noCheck on the server, happyPackMode in the front's Webpack config), and CI ran lint, codegen and the server's tests, not tsc. - One change, one pull request. A new game meant a schema change, a resolver, a game component in ui and a page in front. All of it went into one PR. - End-to-end tests in the same repo. Cypress ran against the server and client from the same commit, so there was never a question of which server version a client build was tested against. - No package publishing. front imported @lp/ui straight from the workspace, so there was no version to bump between them. While the schema changed every week, these were the properties I wanted. What it cost Upgrades When I tried to upgrade Apollo on the server and check that it still returned the same data, codegen failed. As I remember it, the packages had ended up needing different codegen versions. I no longer have the error, so I can't say more about the cause than that. Codegen and its plugins are declared separately in three packages. When upgrading that tooling, I had three configurations and their generated output to check rather than one central setup. Some changes could therefore spread beyond the package I originally wanted to upgrade. Builds Neither image can be built from its own package alone. Dockerfile-server copies packages/shared and runs yarn build:server, which runs codegen before compiling. The front image copies shared, front and ui (Dockerfile-front), because @lp/ui has no build step of its own: its main points at src/index.ts (package.json), and front's Webpack compiles the design system's source. A replacement for Webpack would have to handle that source and its build assumptions too. None of this comes from the monorepo as such. A design system with its own build, or one codegen setup at the root, would have loosened it. I didn't need either when I set the repo up, and the coupling built up gradually. The same setting, in two places The incident I remember best was about a number. Login used a JWT. The server signed it with a lifetime from its TOKEN_TTL variable (token.ts): const tokenTtl = TOKEN_TTL || DEFAULT_TOKEN_TTL; const token = jwt.sign({ id, role }, JWT_SECRET, { expiresIn: isDemo ? '1h' : `${tokenTtl}d` }); The client didn't read the expiry from the token. It computed its own from its own TOKEN_TTL and used it to send me to the login page when the session ran out (auth-hook.tsx): const tokenTTL = Number.parseInt(process.env.TOKEN_TTL || '7'); // ... const TOKEN_EXPIRATION_PERIOD = isDemo ? 3600 * 1000 : 1000 * 60 * 60 * 24 * tokenTTL; I deployed v2 by hand to a small DigitalOcean droplet. Building the images on the droplet was too much for it, so I built them locally, pushed them to Docker Hub and only pulled them on the server. That put the two values in different places. The client's was a build argument in my local script (docker-prod.sh), compiled into the bundle: --build-arg TOKEN_TTL=7 \ The server's was whatever I had typed into its environment on the droplet. I don't remember the exact values, but at one point they didn't match, and the result depended on which side was shorter: - Client shorter: I was logged out while my token was still valid. - Server shorter: the client still thought I was logged in, so instead of a redirect to the login page, every request failed with an error saying I had to log in. Changing the client's side meant rebuilding the image, pushing it and redeploying—all for one number. TOKEN_TTL wasn't the only setting split this way. When I archived v2, I added an ALLOW_SIGNUP flag so that people trying the Docker build could create an account (commit). It had to reach four places: the server's signup check, the client's sign-in and sign-up pages, the server's runtime environment and the client's build arguments. The compose file sets it twice. The shared repository didn't cause this. Two packages each owned the same value, and nothing made them agree. v3: separate repositories once the features settled When I started v3 in 2026, I knew which features I wanted: six games, a scheduler I'd been using for years, and two languages. I was more interested in deploying, upgrading and changing each half on its own schedule. v3 is two repositories: - language-power-api: FastAPI, PostgreSQL, Redis, deployed to Google Cloud Run - language-power-client: React + TypeScript with Vite, deployed to Netlify, which proxies /api to the backend The backend is a single process with feature modules (auth, words, games, dictionary). The two deployables are the backend container and the client's static build. The contract is checked at runtime A Python backend can't share TypeScript types directly. I could have generated them from FastAPI's OpenAPI document. I didn't, because I wanted the two repositories to stay completely separate, with nothing generated from one checked into the other. Instead, the client describes each response in zod, and the wrapper every API call goes through parses the data before the app uses it (http.ts). Calls whose body isn't used, such as logout, pass schema: null and skip it. const result = schema.safeParse(data); if (!result.success) { // ... throw new ApiError("contract", message, response.status, result.error.issues); } A response that doesn't match becomes its own kind of error, "contract", and is reported to Sentry. New fields from the backend are ignored, so adding to a response is safe. A removed or renamed field fails on the first request that hits it. Upgrading FastAPI doesn't touch the client's dependencies, and neither build needs a file from the other repo. One owner for each setting The TOKEN_TTL problem went away for a reason unrelated to the repositories: v3 uses server-side sessions instead of JWTs. The session lifetime exists in one place, session_ttl_seconds: a session lasts 30 days from login. The client doesn't know it. It asks /auth/me who the user is, and a 401 or 403 there means no one is logged in (api.ts). A 401 or 403 from any other endpoint makes the client check /auth/me again. Why I moved to sessions is a separate article. For values the client does need, the backend sends them. GET /auth/config (router.py) returns the settings a logged-out visitor's screen depends on: return { "signup_enabled": service.signups_open(), "signup_open_today": await service.signup_open_today(db), "use_mocks": service.mocks_enabled(), "account_ttl_hours": settings.account_ttl_hours, "searches_per_language": settings.searches_per_language, } signup_open_today couldn't be an environment variable at all. The demo allows a fixed number of new accounts per day, so the value comes from the database and changes during the day. Changing an existing value, such as the demo's account lifetime, needs a backend deploy and no new client build. Adding a field is different: when I added the account lifetime and search limit, the backend change was the router and a test (commit), and the client needed a new release for the two schema fields and the notice that shows them (schemas.ts). The client's application code reads environment variables only for Sentry (config.ts). The deployment needs one more input, API_ORIGIN, which Netlify uses to proxy /api to the backend. What v3 gave up - Drift isn't checked automatically before deploy. If I rename a field in the API and forget the client, testing the two together locally would show it, but nothing in either CI does: neither runs the other side, and there's no contract test between them. Otherwise it fails on the first request in the deployed app, loudly and specifically. - Some rules are copied by hand. The password limits, the limits on a word's fields and the spaced-repetition settings limits exist in both repos. The client's copies say so in comments, such as "Mirrors the server's signup rules (auth/schemas.py)" (password.ts). - A cross-cutting feature is two changes in two repos. The demo limits were a set of backend commits and a set of client commits, tested separately, and the backend had to ship first. - The config isn't refreshed on its own. The client caches /auth/config with staleTime: Infinity (queries.ts). It's fetched again after a signup is refused with a 429 and cleared on logout, but otherwise an open page keeps the value it loaded with. Keeping the repositories separate didn't remove the coupling between them. They still share field names, status codes and the /api prefix. Generating the client's schemas from OpenAPI would make the existing API dependency explicit and easier to check, at the cost of a generation step and its tooling. I accepted hand-written schemas as the simpler start, knowing they need keeping in sync. What I take from it For this app, the setup that suited each stage was different. While the schema changed every week, a single PR across the stack and shared types were worth the cost of upgrading packages together. Once the features settled, I changed the contract less often and cared more about upgrading and deploying each half on its own, and the runtime check has been enough for one developer and one client. The most expensive problem in v2, the token lifetime, didn't depend on the repo layout. It came from the same value being owned in two places. A monorepo could have avoided it by having the client read the expiry from the token, and separate repositories could have repeated it. Before blaming the number of repositories, I'd now look for the specific dependency causing the pain. Next steps - Generate the client's zod schemas from OpenAPI in CI, or add a contract test that runs them against the real API, so drift fails before deploy. - Give /auth/config a response model. It already appears in the OpenAPI document, but with an untyped response ({}), so generation couldn't reproduce its client schema yet. - Serve the validation limits from the backend instead of copying them. Links - Live demo: language-power.netlify.app - v3 backend: language-power-api, with its architecture diagram - v3 client: language-power-client - v2 monorepo (archived): language-power-v2, with the Storybook still deployed - Professional contact: LinkedIn — Mariia Ganza

  25. X@Ryan_Salinger · 30 views

    I was looking for a simple IPTV app that my dad could use. Some existing ones are slow, have complex menus or icons that need interpreting, etc. I worked hard to create something I'm happy with, so I figured I'd share. My first ever open-source app: rsalinger/HappyTV

  26. Location: United States (Open to any US location) Remote: Yes, open to remote, hybrid, or in office Willing to relocate: Yes Technologies: Fortran, Python (including Matplotlib, Numpy, Scipy), OpenMP, Git/GitHub, Linux, Bash, others... Résumé/CV: Available on request Email: trettel.us (to reduce spam, please type in the email address) GitHub: github.com/btrettel Personal website: trettel.us I'm Ben Trettel, a mechanical engineer with about 15 years of experience, specializing in computational fluid dynamics, multi-disciplinary design optimization, and verification and validation of computer simulations. I am particularly interested in opportunities to build cutting-edge physical products where computational simulation and design optimization are key. Please email me at the address above about only specific job opportunities that are matched to my skills and background. Do not email me about generic job opportunities that anyone can apply to or non-job opportunities like advertising your job board or giving me advice on my resume. I am not interested in gig economy type contract work. Recruiters: Send full details of the position including company and job description in the first email. As long as the position meets the criteria above, do not ask if I am interested, just send the details.

  27. Redditu/silverxpup · r/ACNHGifts · 8 points · 20 comments

    Wishlist Extravaganza Hello everyone! Today we are going to be doing a special wishlist giveaway where you can pickup almost ANY ITEM from an ACNHGift mod’s island! 1 stack = 1 item, and we can gift up to 40 items to 1 person. (Note: villagers don’t count towards the “40 items”. But you can only request 1 villager) The only things that we cannot give right now are: * ⁠DLC items (such as some counters and pillars) * ⁠⁠Flower/bush/tree/veggie \*plants\* (seeds and starts are ok) * ⁠⁠Critters (fish, bugs, sea creatures) If you are requesting any DIYs, I suggest learning them ON THE ISLAND in case they are an unflyable DIY (github.com/berichan/acnhmobilespawner/wiki/list-o…) to ensure you don’t lose them. To join, please comment your in-game name and island name along with your wishlist created on catalogue.ac list (this is free of charge) for the ease of mods viewing the items. This allows us to get wishlists fulfilled in a shorter time! NOTE: if comments are locked but the post flair does not say closed, I am catching up on wishlists and they will reopen soon. Re-entry is currently allowed! It’s just me at the moment- so please be patient!

  28. Redditu/jonathanberi · r/embedded

    I open-sourced relaynet: real network access for Zephyr (or any user-space TCP/IP stack) running in a browser Browsers can't open sockets, which makes networking the hard part of running firmware in a browser tab. relaynet is a relay for that. The page sends Ethernet frames over a WebSocket, and the firmware's own stack gets a DHCP lease, DNS and IPv4 TCP/UDP to the internet. There's no socket offload or shim, so you're exercising the real network stack. It's now open source (Apache-2.0) and self-hostable with `docker compose up`: beriberikix/relaynet Where I think it's useful for embedded: - Networking samples that actually run on a docs page - Workshops and trainings where nobody installs a toolchain - Exercising net-stack code in CI without hardware - Sharing a WebUSB device with a Linux machine over USB/IP Zephyr examples: zephyr-wasm-soc (Zephyr compiled to WebAssembly) and a small zephyr-v86 build both work against the hosted instance with no account. Projects like Zephyr in the Browser could add a real network to their emulated boards the same way, if there's interest. I'm happy to help anyone wire it up. The client is a small JS library (npm: relaynet). Bring your own stack: smoltcp, lwIP, Zephyr, or whatever your emulator speaks. Feedback welcome, especially on what an embedded workflow would need from it.

  29. Redditu/nXtrIX · r/HydroThunderHurricane · 29 points · 8 comments

    Near 1:1 Recreation of Hydro Thunder Hurricane had some free-time and fully recreated hydro thunder hurricane mostly byte-for-byte, function-by-function, class-by-class, etc... note that this is obviously ai-assisted, (not vibecoded) nevertheless, it's still very optimized and looks near 1:1. right now, races work and mostly everything works aside from audio and a few graphical bugs. future plans: having a toggle for using the xbox 360 ui (instead of windows ui) and fidelity since i think the xbox 360 version looks way nicer. other plans consist of open-source custom servers with online saving, potential modding support, custom tracks, custom boats, and more. porting wise: i plan on creating builds for linux, macos, and wasm/webgl. however, only windows with directx 11 is currently implemented. my main target platform is my intel atom tesla model 3 so i have to optimize this more than it already is to get a stable frame rate when i add the webgl backend, so that is my main priority. optimization details: ui lookups are cached, which practically doubled the framerate. to achieve more consistent frame times, assets are preloaded which does increase memory usage by about 50mb but its not really an issue, could make a toggle for that just incase. also note that this is single-threaded, the original game had a separate render thread, i plan on implementing that next week or so. suggestions are welcome, here's the repo: NextrixVFX/Hydro-Recomp since this is based off the windows 8 build of the game, you will need the Base.apf from that in order to run this. if you would like to stay updated with it, or just find it interesting, leaving it a star would be appreciated. this took me about 2-3 days to complete. this would've taken weeks longer without utilizing my other project VuDumper for all the classes and structs which I posted about 3 months ago on this subreddit, I released an update for that dumper to generate an ida database to help with reversing aswell. and for comparing to the original game I utilized the unicorn cpu emulator along with ida to make sure all the constructors and other initializers or general functions were correct i/o wise.

  30. X@fibanacci101 · 11 views

    Security-Audit-Skill A coding-agent skill for multi-phase security audits that produces independently verified, machine-readable findings. One of the fastest-growing agent skills right now. cloudflare/security-audit-skill

  31. @wukko, it would be awesome to get some insight on this. helium-services#10

  32. X@okanbarlas · 55 views

    @leodavincs3 Videosu: youtube.com Skill: leodavincs/kalem

  33. X@tilakchow_ · 13 likes · 2 reposts · 722 views

    Day 8/365 ✅ Did Top K Frequent Elements and Longest Consecutive Sequence. Aithaled chat nathoni inka slow cheyali nen idhi😔😭. Code: tilakchow/ai-ml-engineering-journey #365DayChallenge #DSA #Python t.co

  34. X@chinmay_jain_ · 1 like · 4 views

    I use Git daily and had no idea how it works. So I'm building my own, from scratch, in TypeScript + Bun. 🛠️ It's called Gitty. 27 commits in, and I've already lost hours to bugs I'm too embarrassed to explain. Documenting the whole journey here CHINMAYJAI/Gitty t.co

  35. Redditu/Fogboundturtle · r/LeMansUltimateWEC

    Racing online Steward - Alpha 0.8 preview.redd.it preview.redd.it Ever had a contact in mid-race and wondered who was actually at fault? Racing Steward is an automated collision analyzer for sim racers. It runs quietly alongside RaceRoom Racing Experience or Le Mans Ultimate, records your session, detects on-track contacts and breaks down who was responsible. It also replays the whole race from above and gives league stewards the tools to rule on incidents and write a report. You can download this application for free here : fogboundturtle/RacingStewardOnline: Application that analyze races and determine who is at fault. Support LMU/R3E Everything is locally process. This is not using any AI, this is using heuristic but deterministic rules. Of course , Edges cases are difficult to determine. I am still working on the logic. If you submit cases to me , than I can look at them and tweak some more. btw, you can use this as a logger as well. It will save all the cars data and you can replay the whole race. All you need to do is let the application run in the background. it will do the rest.

  36. X@justwasm · 45 views

    现在最新的 Claude Code 逆向工程项目是什么 claude-code-best 已经四个月没更新了 @grok claude-code-best/claude-code

  37. Redditu/Affectionate-Bit5072 · r/LLMDevs · 3 points · 5 comments

    Open-source orchestrator for Claude Code, Codex, agy and OpenCode where the workflow is code, not a prompt (I'm the author) Disclosure up front: I'm the author. It's Apache-2.0 and free, with no hosted part and no pro tier. The problem I kept running into with multi-agent setups was that the process lived in a prompt. Plan, build, review, run the tests, merge: the agent did those when it remembered to. So in Argonauts Code the workflow is code. A workflow is a TOML file of steps (or a script), the built-in ones are written the same way, and the runner executes every step every time. Agents just fill the roles. How it's put together: - Each CLI is driven through its headless structured output, not by scraping a terminal: claude -p --output-format stream-json, codex exec --json, opencode run --format json. ACP agents and a small manifest cover other CLIs. - Builders work in separate git worktrees. Checks run on each task and again on the exact commit you'd merge. - If you don't name reviewers, review goes to a different provider than the builder where the crew has one. - In the Council workflow, seats answer without knowing which model the others run, then talk it out until they agree on a plan. - Local models write code through OpenCode. For reviews, judging and summaries, local servers (Ollama, LM Studio, llama-server, vLLM) are found automatically, and any other OpenAI-compatible server takes a few lines of config. - Headless use: argonauts run --crew --plain --limit-usd 2 "...", an append-only log of every step, argonauts run-review to compare a run's predictions with what happened, and argonauts mcp serve. Testing is where I spent the most thought. None of the 10k+ tests call a model. Each CLI's output is recorded once against a specific CLI version and replayed, and fake CLIs play scripted scenarios for everything else. When a CLI updates, a rerecord script makes a few live calls on its cheapest model and reports which recordings changed shape. On rule 7: most of the code was written by Claude Code agents running in parallel lanes, with separate reviewer agents. I designed it, approved each screen as a text drawing before it was built, and decided what merged. Every change goes through a PR with CI (clippy with warnings as errors, cargo deny, the full test suite). What I don't have yet is a real measurement of whether cross-provider review catches more real bugs than it adds noise. A fair test needs a lot of tasks, repeats and a single-agent baseline, and I haven't run one. If you've done something like that, I'd like to hear how you set it up. It's alpha, macOS and Linux only. The video is a scripted tour on sample data, and its run window, galaxy-style Behaviors view and the mascot arriving at session start come in the next version. Repo: sheng-tse/argonauts-code The built-in workflow files, if you want to see the format: github.com/sheng-tse/argonauts-code/tree/main/cra…

  38. X@VolkNewsDotC0m · 1 like · 57 views

    @Necro______ It's based off Microduck, but I couldn't wait for that and decided to build: github.com/LuwuDynamics/xgoduck_hardware/tree/mas…

  39. X@afarukalbayrak · 1 like · 18 views

    My first software release is here. Who it's for: People who need a quick & easy way to edit their vids without the slow lossy re-encoding of traditional video editing software. Edits are finalized within ms, not minutes. 100MB. Fully open source & free. Thmyris/BBVideoCutter

  40. X@rtmalikian · 23 views

    Open-source Tesla app: Power Share plans an outage — your battery, a 20% reserve floor that never breaks, essentials powered first, loads shed in order. BYD has V2L; Tesla doesn’t (yet). @Tesla @TeslaCharging #Tesla #OpenSource rtmalikian/tesla-power-share

  41. X@ZiBibro · 1 like · 11 views

    It's a small sample, 16 leaders over four epochs on a 0.05 SOL budget, so some results still need more data. The analysis plan went on chain as a hash before the first test, and one command recomputes every result from the raw data: github.com/ZiBibro/solana-validator-tx-ordering/b… t.co

  42. Hedged Requests in Go: Reducing Tail Latency Without Overloading Dependencies Most requests in a distributed system finish quickly. A few don't. Your API might have a median response time of 40ms, while its p99 latency reaches 900ms. Most users get a fast response, but a small percentage experience significantly longer waits. These slow requests are particularly problematic in systems that depend on multiple services. A single slow dependency can delay an entire operation, even when every other component is responding normally. One way to address this problem is request hedging. Instead of waiting indefinitely for an unusually slow request, the client starts another copy after a configured delay. Whichever request succeeds first wins, and the remaining requests are canceled. This technique can significantly reduce tail latency, but it comes with an important trade-off: it generates additional traffic. If every slow request triggers another request without limits, the mechanism designed to improve latency can overload the dependency it's trying to protect. In this article, we'll explore: - What tail latency is and why averages hide it - How hedged requests work - The difference between hedging and retries - How to implement hedged requests in Go - How to cancel losing requests safely - How to integrate hedging with retry budgets and adaptive concurrency - When hedging helps and when it makes things worse - What to monitor and test in production 1. The Problem: Tail Latency Let's say an API receives 10,000 requests. Its response-time distribution looks like this: | Percentile | Response time | |---|---:| | p50 | 40ms | | p90 | 75ms | | p95 | 120ms | | p99 | 900ms | | p99.9 | 2.5s | Looking only at the average or median would suggest that the service is performing well. But 1% of 10,000 requests means 100 requests take at least 900ms. For latency-sensitive applications, these outliers matter. Consider an API that aggregates data from five independent services: API Request | +-----------+-----------+ | | | Service A Service B Service C | | | Service D Service E | | | | +-----------+-----------+ | Final Response If the API needs all five responses, its total latency is constrained by the slowest dependency. Even if four services respond in 30ms, one service taking 800ms can delay the entire operation. This is one reason tail latency becomes increasingly important as distributed systems grow. Jeff Dean and Luiz André Barroso discuss this problem in their influential paper, The Tail at Scale. They describe techniques for building responsive services despite unpredictable latency in individual components. Reference: research.google 2. What Are Hedged Requests? A hedged request is a duplicate request sent while the original request is still in progress. The client does not immediately send multiple copies. Instead, it waits for a configurable period. If the original request hasn't completed, the client sends another request, ideally to a different replica. The first successful response wins. Time | | Primary request | ────────────────────────────────> | | Wait: 100ms | | Hedge request | ─────────────────────> | | Hedge response: 160ms | Primary response: 450ms | | Return hedge response | Cancel primary request | The important detail is that the second request starts before the first one fails. This is fundamentally different from a traditional retry. A retry waits for an unsuccessful attempt before trying again. A hedge assumes that an unusually slow request might be an outlier and starts another attempt proactively. Why does this work? Imagine two replicas: - Replica A is experiencing temporary contention. - Replica B is healthy. The primary request goes to A. After 100ms, it still hasn't completed, so the client sends a hedge to B. If B responds in 60ms, the client returns that response instead of waiting for A. The total latency becomes approximately 160ms instead of 450ms. The original request might still finish later, but its result is no longer needed. 3. Hedging vs. Retrying These mechanisms are related, but they solve slightly different problems. | Mechanism | When the next attempt starts | Primary goal | |---|---|---| | Retry | After an attempt fails | Recover from transient failures | | Hedging | While an attempt is still running | Reduce tail latency | | Timeout | After a deadline expires | Bound waiting time | | Circuit breaker | When a dependency is unhealthy | Stop sending harmful traffic | A retry responds to failure. A hedge responds to excessive waiting. This distinction matters because hedging can increase downstream load even when the original request would eventually succeed. For that reason, hedging should generally be limited to safe, idempotent operations, especially reads. 4. Choosing the Hedging Delay The hedging delay is one of the most important configuration decisions. If the delay is too short, the client duplicates too many requests. If it is too long, the hedge provides little latency improvement. A reasonable starting point is to use a measured latency percentile for a particular operation. For example: | Percentile | Latency | |---|---:| | p50 | 40ms | | p90 | 70ms | | p95 | 100ms | | p99 | 450ms | A 100ms hedging delay means that requests exceeding the p95 threshold become candidates for hedging. Under stable conditions, approximately 5% of requests may reach that threshold. This does not mean exactly 5% of requests will generate a hedge: requests can complete at the threshold boundary, and actual behavior depends on the latency distribution and scheduling. The important principle is to trigger hedging in the tail, not in the middle of normal traffic. The original Tail at Scale paper discusses using a high-percentile latency threshold to limit duplicate traffic while reducing extreme latency. Its examples demonstrate why carefully selected hedging delays can achieve substantial tail-latency improvements with relatively modest additional load. Source: andrew.cmu.edu 5. Implementing Hedged Requests in Go Let's build a small hedging executor. Our implementation will support: - An immediate primary request - A configurable hedging delay - A maximum number of attempts - Context cancellation - First-successful-response semantics - Retryable error classification - An optional shared retry budget We'll use Go generics so the executor can return any response type. Step 1: Define the policy package hedge import ( "context" "errors" "fmt" "time" ) var ( ErrInvalidPolicy = errors.New("invalid hedging policy") ErrBudgetDenied = errors.New("hedging budget exhausted") ) type Budget interface { TryTake() bool } type Policy struct { Delay time.Duration MaxAttempts int Budget Budget ShouldHedge func(error) bool } type result[T any] struct { value T err error } The Budget interface allows us to reuse the retry budget implementation from the previous article. The original request does not consume a hedge token. Every additional request does. We also use ShouldHedge to distinguish errors that should terminate the operation from errors that may allow another attempt. For example, a validation error should not trigger another request. Step 2: Implement the executor func Do[T any]( ctx context.Context, policy Policy, operation func(context.Context, int) (T, error), ) (T, error) { var zero T if policy.Delay <= 0 || policy.MaxAttempts < 1 || policy.MaxAttempts > 3 || operation == nil || policy.ShouldHedge == nil { return zero, ErrInvalidPolicy } if err := ctx.Err(); err != nil { return zero, err } hedgeCtx, cancel := context.WithCancel(ctx) defer cancel() results := make(chan result[T], policy.MaxAttempts) launched := 0 inFlight := 0 var lastErr error startAttempt := func() { launched++ inFlight++ attempt := launched go func() { value, err := operation(hedgeCtx, attempt) results <- result[T]{ value: value, err: err, } }() } // The primary request starts immediately. startAttempt() var timer *time.Timer var timerC <-chan time.Time if policy.MaxAttempts > 1 { timer = time.NewTimer(policy.Delay) timerC = timer.C defer timer.Stop() } for { select { case <-ctx.Done(): return zero, ctx.Err() case res := <-results: inFlight-- if res.err == nil { // First successful response wins. return res.value, nil } lastErr = res.err if !policy.ShouldHedge(res.err) { return zero, res.err } if inFlight == 0 && launched == policy.MaxAttempts { return zero, lastErr } case <-timerC: if launched >= policy.MaxAttempts { timerC = nil continue } if policy.Budget != nil && !policy.Budget.TryTake() { // No more additional requests. timerC = nil if inFlight == 0 { if lastErr != nil { return zero, lastErr } return zero, ErrBudgetDenied } continue } startAttempt() if launched < policy.MaxAttempts { timer.Reset(policy.Delay) } else { timerC = nil } } } } Let's examine the important decisions. The primary request starts immediately. We don't wait for a timer before sending the first request. Additional requests start only after the configured delay. If the primary finishes successfully before the delay expires, the executor returns without sending a hedge. The first successful response wins. As soon as a successful result arrives, the function returns and cancels the shared context. Errors are classified. A fatal error can terminate the operation immediately. A retryable error can be treated as non-final while another attempt is still running. The number of attempts is bounded. The implementation intentionally limits the example to three total attempts, including the original request. This is a conservative default for the example, not a universal limit. Step 3: Use the executor Imagine a service that reads market data from multiple replicas. type Price struct { Symbol string Value float64 } func fetchPrice( ctx context.Context, attempt int, ) (Price, error) { replica := selectReplica(attempt) return replica.Fetch(ctx, "AAPL") } We can now use the hedging executor: policy := hedge.Policy{ Delay: 100 * time.Millisecond, MaxAttempts: 2, Budget: retryBudget, ShouldHedge: isRetryableError, } price, err := hedge.Do( ctx, policy, fetchPrice, ) if err != nil { return err } fmt.Printf( "%s: %.2f\n", price.Symbol, price.Value, ) The primary request goes to the first replica. If it hasn't completed after 100ms, the executor checks the budget and starts another request. If the second replica responds first, the result is returned and the first request is canceled. The example assumes that selectReplica routes attempts to distinct, suitable replicas. Sending both copies to the same overloaded instance may provide little benefit. 6. Cancellation Is Not the Same as Stopping Work This is one of the most important details in a hedging implementation. When the winning request completes, the executor calls cancel() on the shared context. The losing requests receive cancellation through their contexts. But cancellation is cooperative. It does not forcibly terminate a goroutine, an HTTP request, a database query, or server-side processing. For example, a dependency may continue executing a query even after the client disconnects. A correct operation should propagate its context: func fetch( ctx context.Context, client *http.Client, ) error { req, err := http.NewRequestWithContext( ctx, http.MethodGet, "https://api.example.com/prices/AAPL", nil, ) if err != nil { return err } resp, err := client.Do(req) if err != nil { return err } defer resp.Body.Close() return nil } The server should also respect request cancellation where possible. Otherwise, the client may stop waiting while the dependency continues doing unnecessary work. This is especially important for expensive database queries and CPU-intensive operations. 7. Why a Hedge Budget Matters Hedging creates additional traffic. Imagine a service receiving 10,000 requests per second. If 5% reach the hedging threshold, that could mean approximately 500 additional attempts per second. Now imagine the dependency is already degraded. More concurrent requests may increase queueing, which increases latency, which triggers more hedges. The mechanism can create the same kind of amplification problem that we discussed in the Retry Budgets article. This is why the hedge budget should be shared across requests. A simple rule: - The original request is always allowed, subject to normal admission controls. - Each additional hedge requires a token. - Successful normal traffic replenishes the budget. - If the budget is exhausted, no new hedges are launched. For example: budget := retry.NewRetryBudget( 20, 0.1, ) The exact budget should be tuned according to the dependency's spare capacity and the service's traffic patterns. The important part is that hedging is not an unlimited permission to duplicate requests. It is an additional workload that must be controlled. 8. Hedging and Adaptive Concurrency Hedging and adaptive concurrency work particularly well together, but they need to share a consistent view of downstream capacity. Adaptive concurrency adjusts how many requests are allowed in flight based on observed dependency behavior. Hedging creates additional in-flight requests. If the adaptive limiter counts only original requests, hedged requests can bypass the intended concurrency ceiling. That defeats the purpose of the limiter. A safer integration is: 1. The primary request acquires a concurrency permit. 2. A hedge must acquire its own permit. 3. If no permit is available, the hedge is skipped. 4. The winning request returns its result. 5. Every attempt releases its own permit when it actually completes. There is an important implementation detail here. Do not release the losing request's concurrency permit merely because the caller stopped waiting for it. The permit must remain held until the underlying operation actually completes or otherwise confirms that the protected work has stopped. Otherwise, the limiter undercounts active downstream work. This is also why a shared cancellation context alone is not enough to guarantee that hedged work has disappeared. 9. Hedging Requires Idempotency Sending the same operation more than once is not always safe. Consider these operations: | Operation | Hedging suitability | |---|---| | Read a market price | Generally suitable | | Read a portfolio | Generally suitable | | Fetch cached configuration | Generally suitable | | Create a payment | Unsafe without idempotency | | Submit an order | Unsafe without deduplication | | Send an email | May produce duplicates | | Update an account balance | Unsafe without strong safeguards | A hedge can reach two different servers before either has completed. Both servers may execute the operation. Canceling one request does not guarantee that its side effects are rolled back. For operations with side effects, use an idempotency key or another server-side deduplication mechanism. Even then, the server must correctly enforce the idempotency contract. Hedging should generally be introduced first for read-only operations where duplicate execution is safe. 10. Where Should Hedged Requests Be Sent? Sending a duplicate request to the same server is often ineffective. If that server is experiencing CPU contention, a long queue, or an overloaded database connection pool, the second request may suffer from the same problem. Ideally, the hedge should target an independent replica. But independence is not guaranteed. Two replicas may share: - The same database - The same network path - The same cache - The same storage system - The same overloaded region This is called correlated failure or correlated latency. If both requests depend on the same struggling resource, hedging may increase load without meaningfully reducing latency. Replica selection should consider failure domains and actual dependency topology. 11. Observability: Measure the Cost of Hedging A hedging system needs more than a request-latency dashboard. You need to understand whether the reduction in tail latency justifies the additional work. Useful metrics include: | Metric | Type | Purpose | |---|---|---| | hedged_requests_total | Counter | Number of additional attempts | | hedge_wins_total | Counter | Requests where a hedge returned first | | hedge_budget_denied_total | Counter | Hedges rejected by the budget | | hedge_canceled_total | Counter | Losing attempts canceled by the client | | hedge_attempts_total | Counter | Total attempts, including originals | | hedge_delay_seconds | Histogram | Time before a hedge is launched | | request_latency_seconds | Histogram | End-to-end request latency | A useful derived metric is the hedge win rate: [ HedgeWinRate = \frac{HedgeWins}{HedgedRequests} ] If hedges rarely win, you may be generating additional traffic without much benefit. Also compare: - p50 latency - p95 latency - p99 latency - Downstream request volume - Dependency CPU and memory usage - Cancellation effectiveness - Error rate The goal is not to minimize p99 at any cost. It is to improve tail latency while keeping the additional workload within the dependency's capacity. 12. Testing Hedged Requests Concurrency behavior needs deterministic tests. At minimum, test these scenarios: - The primary request succeeds before the hedging delay. - The primary request is slow and the hedge wins. - The primary request fails with a retryable error. - A fatal error cancels outstanding attempts. - The hedge budget prevents additional requests. - The parent context is canceled. - The maximum number of attempts is respected. - Losing operations receive cancellation. - A losing operation that ignores cancellation does not release its concurrency permit prematurely. A simple test for the winning hedge could use controlled channels instead of arbitrary sleeps: func TestHedgeWins(t *testing.T) { primaryStarted := make(chan struct{}) hedgeStarted := make(chan struct{}) ctx, cancel := context.WithTimeout( context.Background(), time.Second, ) defer cancel() policy := Policy{ Delay: 20 * time.Millisecond, MaxAttempts: 2, ShouldHedge: func(error) bool { return true }, } result, err := Do( ctx, policy, func( ctx context.Context, attempt int, ) (string, error) { if attempt == 1 { close(primaryStarted) <-ctx.Done() return "", ctx.Err() } close(hedgeStarted) return "hedge response", nil }, ) if err != nil { t.Fatal(err) } if result != "hedge response" { t.Fatalf( "unexpected result: %s", result, ) } <-primaryStarted <-hedgeStarted } The test verifies that the second request can win and that the operation completes successfully. In a complete test suite, also verify that the primary operation observes cancellation. Run the race detector: go test -race ./... Finally, use load tests with a dependency that deliberately introduces variable latency. A useful experiment compares: 1. Hedging disabled. 2. Hedging enabled with a conservative delay. 3. Hedging enabled with an aggressive delay. 4. Hedging enabled with a shared budget. 5. Hedging enabled with adaptive concurrency. Compare both latency improvements and additional downstream traffic. 13. Production Checklist Before introducing hedged requests into a production service: - [ ] Hedge only safe, idempotent operations. - [ ] Select a delay from measured latency distributions. - [ ] Use a strict maximum attempt count. - [ ] Require a shared budget for additional attempts. - [ ] Ensure hedges target independent replicas where possible. - [ ] Apply concurrency limits to every attempt. - [ ] Propagate context cancellation. - [ ] Ensure permits remain held while work is still active. - [ ] Respect the original request deadline. - [ ] Measure hedge win rate and additional traffic. - [ ] Test correlated latency and dependency overload. - [ ] Roll out gradually and compare against a no-hedging baseline. Conclusion Tail latency is one of the most difficult problems in distributed systems because a small number of unusually slow operations can dominate the response time of an entire request. Hedged requests provide a way to reduce that impact. By launching a second request after a carefully selected delay, a client can avoid waiting for an unusually slow replica and use the first successful response. But hedging is not free. Every additional request consumes capacity, and uncontrolled duplication can make an already degraded dependency even slower. The right approach combines measured hedging delays, idempotent operations, cancellation, retry budgets, and adaptive concurrency limits. The goal isn't to send more requests. It's to get the response sooner without making the system slower for everyone else. --- References - The Tail at Scale — Google Research - Request Hedging — gRPC Documentation - gRPC Retry and Hedging Design

  43. X@chinmay_jain_ · 1 like · 11 views

    I use Git daily and had no idea how it works. So I'm building my own, from scratch, in TypeScript + Bun. 🛠️ It's called Gitty. 27 commits in, and I've already lost hours to bugs I'm too embarrassed to explain. Documenting the whole journey here CHINMAYJAI/Gitty t.co

  44. X@MrFairtax · 12 views

    Do not waste your time with fairtax.org github.com/RuntimeRepublic t.co

  45. X@imSrohitS · 5 views

    @NautilusTrader The best part of NautilusTrader: my backtest code and my live trading code are the same code. No rewrite between research and production. Rust core, Python on top, and it's open source. nautechsystems/nautilus_trader

  46. Install in two commands: claude plugin marketplace add rachhek/claude-plugins claude plugin install buddy@rachhek rachhek/claude-plugins

  47. Hacker NewsKingPinX · 1 point · KingPin/Garrul

    Show HN: Garrul – Comments system for your site on a single Cloudflare Worker I needed a comments system for my blog (running on Cloudflare & Astro), the other options I tried didn't work out as I wanted. So Garrul was born, it uses one Cloudflare Worker with D1 + KV, in your own account. No container, no VPS, no DB server to manage or worry about! Most sites fit the free tier, I am using it for 5 lowish traffic sites with zero issues. I wanted privacy of commenters to be primary here, along with ease of use so that was always the basis of many decisions I took along the way. For example, we never store IP addresses directly. Every IP is HMAC hashed, ipv6 is truncated first. I have worked steadily on optimizations every chance, e.g. instead of having few separate calls for the config, session, first set of comments, subscription state etc it's all a single call. Posting costs a single call, you can even have a reaction only mode for specific pages/articles. The anti-spam call and turnstile call only happen when user actually focuses the comment posting embed. The math works out to roughly 100k pageviews/day on the free tier. The widget embed itself is limited to 30KB gzipped, with the CI set to fail above that so we don't ship massive embeds. One of the larger issues with trying to stick within Cloudflare free tier is the 1000 writes/day for KV. We used to have per request KV Cache, that burned me when I woke up to my first bot swarm browsing thru the site and locking out the comments for the whole day. That made me move the cache to the cache API. Demo (anonymous posting works) : garrul.com I would appreciate any feedback on improving the system. Optimization and security are my current focus, so anything anyone can help with there will be immensely appreciated. Some of the feature highlights : Threaded markdown enabled comments OAuth (Google, Facebook, X, Discord, GitHub logins) or Anon posting pinned comments, opt in reply emails, digest of posts to moderators, and a telegram bot to moderate the whole thing from telegram itself (I use this telegram bot daily). Multiple languages, and ability to import from multiple systems like Disqus and Remark42 among others. Licensed as Apache2.0. So it is tied to Cloudflare for now, meaning even tho Cloudflare D1 is simply SQLite, you can't just run it anywhere other than CF. In our case your data can be exported as a plain SQLite dump (via npm run db:export) or json or CSV from the admin panel, whenever you need it. I used AI assistance heavily for this, coding, tests, and red-teaming. I review what goes in and CI catches a lot.

  48. (´・ω・`)Windows XP Vista 7向けにFireFoxの最新版がインストール出来るってすげーな。 github.com/e3kskoy7wqk/Firefox-for-windows-7-REWO…

Older posts →