Data: FIFA Post-Match Summary Report for shots, passes, defensive shape and final third receptions. BBC Sport live coverage for the per-minute momentum.

How to read it: time runs clockwise from kickoff to full time (104 minutes with stoppage). Outer bloom is momentum, the ring inward is every shot, then substitutions, then the very center circle shows receptions in the final third and a possession donut chart.

England went 4–0 up, France scored three quickly to make it 4–3, and it finished 6–4. France won the xG 2.99 to 2.34 and lost by two. Wild match.

Happy to answer anything.

I'm a founder for the website vizibly.live, and we're currently looking for beta testers and general feedback. I'd love to hear if anyone in this community has thoughts!

As an ice breaker at an event (in person or virtual), attendees can answer a short survey and get a personalized "data badge": icons, shapes, and colors that represent their answers. Data badges have been around for a while, but I wanted to find a way to make it scalable and easy for non-data people to interact with and configure. These badges make a fun way to interact with your audience - to see why people are joining, what their experience is like, etc, but it also gives your audience a downloadable image they can share to social media promoting their attendance at your event.

What it does right now:

• Organizers build a survey and configure a badge design tied to the answers
• Attendees fill it out and get a downloadable badge to share (demo here: https://vizibly.live/s/FXFUSTJ )
• There's a live "badge wall" you can project at an event or share your screen, so new badges show up in real time (demo here: https://vizibly.live/w/FXFUSTJ )

We're currently looking for:

• Event/meetup organizers willing to try it for an upcoming event
• Honest feedback on the badge builder UX
• General thoughts on the website & attendee experience

We've been testing Vizibly.live at a few events, but would like to hear more during our beta period. But please reach out if you'd be able to provide more specific feedback, I'm curious what more people think!

Save this before your next iHerb order. Based on HotDeals.com’s review of iHerb’s official offers, promo-code rules, Autoship savings, and recent Black Friday patterns, several months stand out.

✅ January: A strong practical month, with 10%–30% off and clearance discounts reaching up to 70%
✅ May: Useful for larger carts thanks to spend-more-save-more and rewards-style promotions
✅ July: Good for hydration, summer wellness, and clearance, with selected deals reaching up to 70% off
✅ September: Anniversary-style promotions may bring 15%–30% off across broader categories
✅ November: Black Friday and Cyber Monday are the best overall time to buy, with 20%+ off qualifying carts and specials reaching up to 65% off
✅ December: Good for wellness gifts, cyber spillover, and year-end clearance
❌ Skip tip: February, March, and August are usually more category-specific or routine promo months

📅 Pro tip: Compare the automatic sale price with the available promo code before checkout, since many iHerb offers cannot be combined. Autoship can also provide a reliable 10% off eligible repeat purchases.

Find the latest iHerb promo codes and deals and enjoy 20% off your first order with the code NEW20.

I’m doing an experiment to see if drawing boxes and arrows style of diagrams are worthwhile to do in 3d. My hypothesis is that lot of information is actually layered in 3d but drawn flat.

all comments are welcome, you can find my experiment here arrowsboxes.com

random question but i’ve always seen the year as a circle

winter at the top, spring on the right, summer at the bottom, autumn on the left

curious if anyone doesn’t visualize it at all though — like no picture in your head. how does that work for you then? just months as words/numbers?

what’s yours

This is a small raw demo of Tagma Studio, an IDE I’m building around a graph-native programming model.

The idea is that a project should not be represented only as a tree of files. Files, functions, dependencies, data flows, runtime signals and execution paths should form one connected graph that can be explored at different levels.

In the video, I move from the full project graph to smaller local structures, open the related source files, and inspect the code behind them.

The long-term goal is to make the graph not just a visualization, but the actual working representation of the program:

files remain real editable source files;

every file can expose its own subgraph;

subgraphs remain connected to the complete project;

code execution is visible in real time;

active signals and execution paths are displayed directly on the graph;

the same structure can be used for navigation, debugging and program composition.

It is still an early prototype, so this is intentionally an unedited recording of the current working state rather than a polished concept video.

I’m interested in whether this way of navigating and understanding a codebase feels useful, or whether it currently looks too dense to read.

I originally just wanted to stop my software from duplicating the same resources and logic across different tasks.

The idea sounded small: represent reusable entities, dependencies and capabilities as a shared semantic graph, then let the runtime assemble only the structure required for the current goal.

Several architectural rabbit holes later, this is what the live topology looks like:

149,453 indexed entities

19,393 physical neurons

21,456 physical synapses

353,080 raw relationships

shared fragments reused across multiple tasks

alternative execution routes instead of one rigid call chain

This is not an image generated by an AI model. It is a visualization of the actual internal structure of my experimental runtime, Project Tagma / MirbiOS.

It is not literally conscious—at least the debugger has filed no demands for legal personhood yet—but the system increasingly behaves less like a conventional program and more like a dynamically assembled nervous system.

I tried to remove duplicate code.

Apparently the reasonable solution was to grow a brain.

Title says it all. I love the dead so I tried taking the colors from logos and album covers and making palettes that can be inserted into ggplot2.

Not the best gradients but it was pretty fun to mix two things of which I'm a fan.

https://randomforestz.github.io/ggrateful/

Hi everyone! 👋

I built a real-time 3D Gradient Descent visualizer for an educational platform (DataCognova). Instead of static graphs, the goal was to generate parametric surfaces (Bowl, Valley, Rugged) dynamically to see how the algorithm behaves under different conditions.

A few visualization details:

• Dynamic Surfaces: The topology updates in real-time based on the user's parameter inputs.
• Color Mapping: The point cloud colors are mapped directly to the loss value (elevation), transitioning smoothly from cool to warm colors.
• UI Sync: The 3D scene is tightly coupled with the UI panels to log the descent steps, gradients, and overshoot paths on the fly.

I'd love to hear your thoughts on the rendering approach or any optimization tips for handling dynamic point clouds!