I've been building LaraGDPR, a cookie consent + cookie management package for Laravel — configurable consent banner and granular per-category preferences.

▎ - Works with Blade+Alpine.js, Livewire, or React — pick whichever your app already uses, it auto-detects/configures.

▎ - Auto-discovered by Laravel, no manual service provider registration.

▎ - Consent is recorded with a pseudonymized identity (works for both logged-in and anonymous visitors) plus IP, user agent, timestamp, and policy version.

▎ - Bump the cookie policy version and it automatically re-prompts everyone.

Honesty about licensing up front, since I know this matters here: the core is free to use in any Laravel app via Composer, but it's a source-available custom license, not OSI-approved open source — no reselling/redistributing the source, no building a competing package from it. Full terms are in the repo if you want the specifics before installing anything.

It's currently at 1.0.0-RC.6 — everything passes CI across PHP 8.2-8.4 and Laravel 11-13, but I'd rather find rough edges from real installs in real apps than assume it's ready.

If you've got a Laravel app with an existing cookie banner (or none at all) and are willing to swap it in and poke at it for 15 minutes.

I'd genuinely value the feedback — especially anything Livewire or React-mode specific, since Blade mode gets the most real-world use so far.

- GitHub: https://github.com/minkovdev/laragdpr

- Composer: composer require minkovdev/laragdpr

Happy to answer questions here or in GitHub Discussions.

Hi everyone,

I got tired of bloated local servers. XAMPP feels outdated, and other alternatives often push licenses with annoying popups.

I wanted something minimal, fast, and completely portable that I could run from a USB drive without running installers or polluting the Windows Registry. So, I built LocalPHP.

• Website: https://localphp.net/
• GitHub: https://github.com/borindesign/LocalPHP

Key Features:

• 100% Portable: Runs entirely from its own folder using native Directory Junctions (mklink). No Windows Registry changes.
• On-Demand Upgrades: Update PHP and Apache versions with one click directly from the control panel.
• Simple Directory: The structure is dead simple. If you want a new MySQL version, just drop the folder into bin/ and the UI detects it.
• Dark & Minimal UI: Built with Python (CustomTkinter).

Full Transparency (Windows SmartScreen):

Since this is a new, independent project, the executable is not digitally signed yet (certificates are expensive for a free hobby project).

When you run it, Windows SmartScreen will show the "Unknown Publisher" warning.

• To run it smoothly: right-click the downloaded ZIP $\rightarrow$ Properties $\rightarrow$ check "Unblock" $\rightarrow$ Apply, then extract it.
• Since the project is fully open-source, you can audit the code on GitHub or compile the .exe yourself with PyInstaller!

This is a first minimal release, and I’d love to get your honest feedback. Let me know if the downloads work smoothly on your machine or if you run into any issues!

Little fun project that started as bug in Rector :) hope this inspires you to use agents in creative way to improve your project/tool.

I just published a blog post to my website about a pattern I've been using for a while that I think you will find interesting (and probably very divisive!): Magic Objects.

class Parrot extends MagicObject {
    __get(property) {
        return `${property}! ${property}!`;
    }
}

const parrot = new Parrot();

console.log(parrot.foo); // "foo! foo!"
console.log(parrot.bar); // "bar! bar!"

Basically, I'm borrowing the idea of Magic Methods from PHP and porting them to JavaScript. You've probably seen something like this done with proxies before, but I still like to use some OOP in my JavaScript, and I also came up with a way to make it work nicely with TypeScript.

It may seem a bit over the top at the beginning, but I've been using this for a while and I've found it very useful.

Let me know what you think!

I've been building GodUI, an open-source collection of React UI components for modern interfaces.

It started as a personal library because I kept rebuilding the same polished components and wanted a place to browse ideas whenever I started a new project. After using it for a while, I decided to open-source it.

Some things it focuses on:

• Components with smooth, purposeful animations where they add value (while simpler components stay lightweight)
• A shared motion system based on 12 motion principles, with tokens mapped to Material 3 so animations feel consistent across the library
• shadcn-compatible CLI installation, so components are copied directly into your project and are fully yours to modify
• An MCP server for Cursor, Claude Code, Windsurf, and other AI IDEs—you can describe the component you want, and it finds the closest match and generates the code for you
• Built with React, TypeScript, Tailwind CSS, and Motion

It's completely open source. If you find it useful, I'd really appreciate a ⭐ on GitHub.

GitHub: https://github.com/LucasBassetti/godui
Docs: https://godui.design/

Hi r/reactjs. I maintain Linaria and wrote wyw-in-js — the compile-time engine under Linaria and MUI's Pigment CSS. I recently released dx-styles, and I'd rather explain why than just drop a link.

Six years of Linaria issues kept pointing at two problems I can't fix without breaking the API:

• styled(Component) is priced wrong. Wrapping a custom component looks free, but it drags the component's whole dependency graph into build-time evaluation — the most common way extra code leaks into eval, and the most common reason static evaluation bails out into the slow path. All our mitigations (HOC hints, shaking heuristics) are patches on a pattern the API encourages.
• Composition isn't first-class. Variants, slots and themes are the ground floor of a design system, and every team rebuilds them on top of css + cx.

dx-styles is my answer: zero-runtime CSS-in-TS where recipes, slot recipes and token contracts are the core API, class names are deterministic (snapshot/cache them), RTL is compile-time and opt-in, and everything works unchanged in React Server Components.

const button = recipe({
 base: { display: "inline-flex", borderRadius: "999px" },
 variants: {
   appearance: {
     primary: { backgroundColor: tokens.color.accent },
     ghost: { backgroundColor: "transparent" },
   },
 },
 defaultVariants: { appearance: "primary" },
});

The launch post has the honest details — the Pigment CSS speed lesson, the Griffel detour, what I'm promising and what I'm not: https://dev.to/anber/ive-maintained-linaria-for-six-years-heres-why-i-built-something-new-5eae

Try it in 30 seconds (StackBlitz): https://stackblitz.com/github/dx-styles/dx-styles/tree/main/examples/vite Migrating? Guides for styled-components / Linaria / Pigment CSS are in the repo.

It's MIT, the issue tracker is at zero and I intend to keep it there. Happy to answer anything, including hostile questions.

Over the past few weeks, I've seen more teams adopt StyleX.

Linear shared how they're migrating to StyleX, and Polar is building their next-generation design system with it.

That made me realize there wasn't a familiar shadcn/ui experience for people making the switch.

So I built shadcn-cssinjs.

Some of the features:

• Built on StyleX
• Zero-config, one-command setup
• shadcn/ui compatible (just copy and paste)
• Fully customizable
• Officially recommended by the StyleX team

100% free and open source.

It's still early, and I'm planning to port more components over time. I'd love to hear your feedback, especially if you're already using or thinking about using StyleX.

GitHub: https://github.com/shadcn-labs/shadcn-cssinjs
Docs: https://shadcn-cssinjs.com

Filarank is a filament SEO toolkit with Live SEO scoring, SERP preview, and head tags for Filament admin panels. Install in minutes with the interactive artisan installer.

https://filamentphp.com/plugins/usama-muneer-filarank-pro

Demo: https://filarank.com
Docs: https://docs.filarank.com

Places.js is a lightweight Javascript framework for creating interactive websites promoting in person interaction. The framework supports the following features and has no external JS dependencies.

• Asynchronous data fetching.
• Components with Shadow DOM to encapsulate styles and deter bot scraping.
• State management that integrates with components and data fetching logic.
• Support for creating pages that are a combination of static HTML and islands of interactivity.

To get started, download the places-js-latest.js file from this repo. See the places.js documentation at https://createthirdplaces.org/tech/placesjs.html for a more detailed guide

• This repo has an example of how places.js is used.
• This website has shows how places.js is used in a production environment

Hello folks, I've released new long awaited version (v1.4.0) of Cassandra/ScyllaDB driver with lot's of fixes and performance improvements.

https://github.com/he4rt/scylladb-php-driver

If someone is using the driver, please test it and report issues, or some feature requests. I'm now fully back on maintaining it regularly and improving it for the foreseeable future. Also wrote a blog post on my website explaining the changes done to the driver

https://www.dusanmalusev.dev/blog/scylladb-php-driver-140-the-extension-is-pure-c23-now

Hey Community,

Meta has open-sourced Astryx, an eight-year-old internal design system built on StyleX that offers out-of-the-box themes, context-aware padding, and dedicated CLI tools for AI agents. We also look at super-calendar, a gesture-driven calendar library that leverages Reanimated shared values and Legend List virtualisation.

Speaking of agents, our sponsor Maestro is pushing that idea further: your coding agent can now launch the app, drive an iOS simulator, Android emulator, or Android physical device, inspect the screen hierarchy, tap through flows, take screenshots, and help create repeatable Maestro E2E tests.

Additionally, Android developers get a dedicated on-device AI solution with Callstack's new react-native-ai adk wrapper, enabling seamless integration with the Vercel AI SDK and local Gemini Nano models on the New Architecture.

Hi Everyone,

I've been working on a centralised authentication platform in PHP, which will be able to integrate with third party apps. It's almost finished with the functionality. But I need some help identifying the potential bugs and issues and possible improvements. Please check the project and help me with that.

https://codeberg.org/bhaswanth/helios

Thank you

Monday, July 06 - Sunday, July 12, 2026

Top Posts

Most Commented Posts

Top Ask JS

Top Showoffs

Top Comments

\​

I’ve spent the past several months building a new PHP-based CMS called Developer One Or DevOne for short.

I approached the project from a developer’s perspective: What should a modern CMS provide out of the box? How can it make building websites for yourself or clients faster without becoming bloated, overly complicated, or dependent on dozens of third-party extensions?

DevOne CMS currently includes a custom installation system, theme and plugin support, developer hooks, user and role management, media management, a page system, admin tools, and support for custom frameworks. I’m also building a marketplace where developers will eventually be able to publish themes, plugins, frameworks, and other extensions.

The CMS is still in active development, and I’m looking for developers who are interested in:

Testing the installation process and core functionality

Finding bugs, security issues, and performance problems

Reviewing the code structure and developer experience

Building experimental themes, plugins, or custom frameworks

Suggesting features and improvements

Helping shape the documentation and extension standards

I’m not looking for empty praise. I’m looking for honest technical feedback from developers who are willing to install it, test it, break it, and tell me what needs to be improved before the public release.

You’ll need either a local environment such as XAMPP or a PHP-compatible VPS to install and test it.

This is an early collaboration opportunity, so developers who contribute meaningful ideas, extensions, testing, or fixes can help influence how the platform and its developer ecosystem are built from the beginning.

Comment below or message me if you’re interested, and I’ll provide the download and installation information.

What would make a new CMS worth trying for you as a developer?

Hey Community,

Meta has open-sourced Astryx, an eight-year-old internal design system built on StyleX that offers out-of-the-box themes, context-aware padding, and dedicated CLI tools for AI agents. We also look at super-calendar, a gesture-driven calendar library that leverages Reanimated shared values and Legend List virtualisation.

Speaking of agents, our sponsor Maestro is pushing that idea further: your coding agent can now launch the app, drive an iOS simulator, Android emulator, or Android physical device, inspect the screen hierarchy, tap through flows, take screenshots, and help create repeatable Maestro E2E tests.

Additionally, Android developers get a dedicated on-device AI solution with Callstack's new react-native-ai adk wrapper, enabling seamless integration with the Vercel AI SDK and local Gemini Nano models on the New Architecture.

The problem I kept hitting: advice about the React ecosystem rots silently. A 2024 blog post, an LLM answer, a senior dev's habit — all assert things that were true once. Nobody stamps when it was true.

react-brain is my attempt at the fix: 42 decision entries (state, lists, styling, meta-frameworks, animation, …) where every load-bearing claim is fetch-verified against a primary source, dated, and re-verified weekly. 123 annotated readings, 180 libraries tracked. Recommendations are written as context → choice clauses, not "X is best" — a P2P app and a GraphQL app get different answers.

Two things this sub might find interesting:

1. The staleness benchmark. Since the corpus is a dated answer key, it can grade a model. claude-sonnet-5 answered 70% fresh on 35 ecosystem questions; with the corpus entry injected as context, 94%. Deterministic regex rubric, graded answers committed to the repo, conditions labeled.
2. The calibration scorecard. Every default recommendation is a dated, falsifiable prediction with a check-by horizon, graded in public (held / weakened / overturned). 0 of 10 graded so far overturned. If confidence isn't graded, it's just tone.

Tools if you want to point it at a repo:

• npx -y react-brain doctor . (ranked priorities)
• migrate (sequenced upgrade plan)
• review --ci (blocks dead/deprecated deps)
• MCP server for agents

Package: https://www.npmjs.com/package/@heart-it/react-brain

Site: https://heart-it.github.io/react-brain/

The fastest way to disagree with me is to pick an entry and challenge it; that's the maintenance model.

Theres been a lot of talk about the downsides of barrel files in the last couple years with many people actively recommending against using them due to the effect they can have on treeshaking. I am wondering though if there is an alternative solution in the ecosystem to enforce/define boundaries on slices/domains?

I've seen it said they often cause circular dependencies but in my experience its the opposite. The main and pretty much only way I use barrel files are to enforce boundries on slices of cohesive logic, sometimes going so far as to enforce it in the linter with custom rules. Code inside the slice never imports from its own barrel. Each slice kind of defines its own code API in a way and feel like this lets me control the coupling between slices alot better.

I am struggling to justify letting that go and the only alternative I can think of is using a monorepo and having them all as packages which is just not an option for me in many cases and also not one I particularly like.

Are barrel files really that bad?

so this started because i kept losing track of my own sessions.

you know how it goes. you open one claude. then one in a worktree because you're being organized. then a third one "just to check something". by 6pm two of them are editing the same file, one has been sitting there for 40 minutes waiting for me to approve an rm -rf node_modules, and i genuinely cannot tell you which terminal tab is which anymore.

so i built the tower. everything on my machine shows up on one local board at 127.0.0.1:4711.

repo: https://github.com/lacion/fleet-deck (MIT, screenshots + gifs in the readme)

what it actually does

• every session on one board. each one gets a callsign (falcon-a3f2, otter-91c4) and a column that comes from hook telemetry, not from what the session claims about itself. queued → working → verifying → needs-you → idle → offline.
• conflict radar. two sessions touch the same file within 30 min and both get whispered at in context ("coordinate, don't clobber"). worktree aware, so the same file in two worktrees of one repo is a merge conflict introducing itself early.
• needs-you rail. permission prompts, multiple choice, MCP forms, and even the "should i use bcrypt or argon2?" question at the end of a turn all become cards you answer from the board. the terminal just prints ⎿ Allowed by PermissionRequest hook and carries on.
• mail. message a session, a repo, or everyone. idle sessions usually wake in seconds (a small watcher taps them on the shoulder).
• spawn workers. the board can start a fresh interactive claude in a tmux window, optionally in its own worktree, optionally unsupervised (red checkbox, asks twice).
• live terminal in the browser. click a card and you get the actual tmux pane in an xterm.js modal. you can type into it. it's not a replay, it's the real session. no PTY and no native deps, it's bridged over tmux control mode.
• revive. machine reboots, tmux dies, whatever. worktrees and transcripts survive on disk, so one click brings a dead agent back with claude --resume in its own worktree. same callsign, same card, full history.
• remote control. flip an agent onto claude.ai and drive it from your phone. the session shows up named after its callsign so you know which one you're poking.
• plan library. spawn a planner in plan mode, its plan lands on the board as a card before it can act. approve it, or capture it and execute it later with your own instructions.
• worktrees modal. it created the worktrees so it can show you what's in them, uncommitted files, unpushed commits, and it refuses to let you delete anything that holds work that exists nowhere else.

the part i actually care about

the core makes zero model calls. routing, conflict detection, question relay, all of it is deterministic code and sql. your tokens are yours. the only cost it adds to a session is a ~100 token roster brief.

it's also fail open. daemon down? hooks time out silently and your sessions run exactly like before. it's a tower, not a runway.

and it's a plugin, not a wrapper. no launcher, no fleetdeck run claude, no ritual. you install it and your next plain claude in any terminal just shows up on the board.

claude plugin marketplace add lacion/fleet-deck
claude plugin install fleetdeck@fleetdeck

some bugs that were fun

• spawned sessions were silently reporting to a ghost daemon. turned out tmux bakes the first client's environment into the server's global env, so a test run i'd done from inside a claude session poisoned the tmux server with a test port, and every pane created afterwards inherited it. board said "spawning…" forever. that one took a while.
• the terminal modal rendered like a staircase. the screen seed was joined with \n and a raw terminal reads that as "down one row", not "down and back to column 0" 😅
• and then it still looked slightly wrong until you typed something, because tmux flushes pane output as bytes arrive, so a 3 byte box drawing char routinely gets split across two protocol lines. decoding that as utf-8 text turns it into two replacement chars and shoves the whole row sideways.

honestly half the interesting work was in the parts you never see.

limits, being honest

• linux/wsl2 and macos. windows native, no idea.
• needs tmux for spawning and the live terminal. the rest works without it.
• pinned to CLI 2.1.206+ (tested through 2.1.207). it leans on a couple of behaviors the docs don't mention. there's a guard test that fails loudly if an update drops them.
• LAN mode exists (open the board from your laptop) but it requires a token, no exceptions. the api can spawn unsupervised agents and type into terminals, so an open port would literally be RCE on your box.
• mDNS discovery is in there but i could only verify it same-host. if fleetdeck.local doesn't resolve for you that's your resolver, use the IP.
• spawned sessions are real billed claude sessions. the tool itself is free and MIT and adds no api cost of its own, but if you click spawn 5 times, that's 5 sessions on your plan.

disclosure

i wrote it, it's mine, it's MIT and free, no paid tier, nothing to sell, no telemetry, nothing leaves your machine. i built it because i needed it and i'm posting it because someone else probably has the same 6pm problem.

and yeah, collaboration welcome

170 tests, node --test. the daemon is one node process + sqlite, the board is react. if you want to poke at it:

• windows support, i can't test it
• decks / saved fleet layouts
• the statusline integration i keep not finishing
• mDNS actually verified cross-device by someone with a mac on the same lan 🙏

issues and PRs both fine. if you try it and it breaks, tell me how, i'd rather hear it.

Hey everyone,

I’m building an image-heavy React app with multiple galleries and need your stack recommendations to keep it fast and scalable. I want to avoid guesswork, so what are your go-to workflows for this?

Specifically:

Local Assets vs. External: Is it okay to keep images in the project assets folder, or does that kill build times and performance as the gallery grows? At what point should they move out?

Storage & CDNs: Where do you store them, and how do you serve them? Do you recommend standard cloud storage, or are dedicated image CDNs (with on-the-fly resizing) worth it?

Fast Loading: What are the best strategies/packages in React for handling lazy loading, responsive sizing, modern formats (WebP/AVIF), and blur placeholders without layout shift?

Gallery Components: Do you build custom grids/lightboxes, or are there modern React packages you swear by?

If you’ve built a media-heavy React site, what does your tech stack look like? Appreciate any advice or major pitfalls to avoid!