CodePen Blog
Chris’ Corner: Rounded Triangle Boxes and Our Shapely Future

I enjoyed Trys Mudford’s explanation of making rounded triangular boxes. It was a very real-world client need, and I do tend to prefer reading about technical solutions to real problems over theoretical ones. This one was tricky because this particular shape doesn’t have a terribly obvious way to draw it on the web. https://blog.codepen.io/wp-content/uploads/2025/04/motorway-cvt-1024x412.jpg CSS’ clip-path is useful, but the final rounding was done with an unintuitive feGaussianBlur SVG filter. You could draw it all in SVG, but I think the % values you get to use with clip-path are a more natural fit to web content than pure SVG is. SVG just wasn’t born in a responsive web design world.

The thing is: SVG has a viewBox which is a fixed coordinate system on which you draw things. The final SVG can be scaled and squished and stuff, but it’s all happening on this fixed grid.

I remember when trying to learn the <pathsyntax in SVG how it’s almost an entire language unto itself, with lots of different letters issues commands to a virtual pen. For example:

* M 100,100 means “Pick up the pen and move it to the exact coordinates 100,100”
* m 100,100 means “Move the Pen 100 down and 100 right from wherever you currently are.”

That syntax for the d attribute (also expressed with the path() function) can be applied in CSS, but I always thought that was very weird. The numbers are “unitless” in SVG, and that makes sense because the numbers apply to that invisible fixed grid put in place by the viewBox. But there is no viewBox in regular web layout., so those unitless numbers are translated to px, and px also isn’t particularly responsive web design friendly.

This was my mind’s context when I saw the Safari 18.4 new features. One of them being a new shape() function:

For complex graphical effects like clipping an image or video to a shape, authors often fall back on CSS masking so that they can ensure that the mask adapts to the size and aspect ratio of the content being masked. Using the clip-path property was problematic, because the only way to specify a complex shape was with the path() function, which takes an SVG-style path, and the values in these paths don’t have units; they are just treated as CSS pixels. It was impossible to specify a path that was responsive to the element being clipped.

Yes! I’m glad they get it. I felt like I was going crazy when I would talk about this issue and get met with blank stares.

Tyrs got so close with clip-path: polygon() alone on those rounded arrow shapes. The % values work nicely for random amounts of content inside (e.g. the “nose” should be at 50% of the height) and if the shape of the arrow needed to be maintained px values could be mix-and-matched in there.

But the rounding was missing. There is no rounding with polygon().

Or so I thought? I was on the draft spec anyway looking at shape(), which we’ll circle back to, but it does define the same round keyword and provide geometric diagrams with expectations on how it’s implemented.
An optional <lengthafter a round keyword defines rounding for each vertex of the polygon.
There are no code examples, but I think it would look something like this: /* might work one day? */
clip-path: polygon(0% 0% round 0%, 75% 0% round 10px, 100% 50% round 10px, 75% 100% round 10px, 0% 100% round 0%);
I’d say “draft specs are just… draft specs”, but stable Safari is shipping with stuff in this draft spec so I don’t know how all that works. I did test this syntax across the b[...]

rowsers and nothing supports it. If it did, Trys’ work would have been quite a bit easier. Although the examples in that post where a border follows the curved paths… that’s still hard. Maybe we need clip-path-border?

There is precedent for rounding in “basic shape” functions already. The inset() function has a round keyword which produces a rounded rectangle (think a simple border-radius). See this example, which actually does work.

But anyway: that new shape() function. It looks like it is trying to replicate (the entire?) power of <pathbut do it with a more CSS friendly/native syntax. I’ll post the current syntax from the spec to help paint the picture it’s a whole new language (🫥): <shape-command= <move-command| <line-command| close | <horizontal-line-command| <vertical-line-command| <curve-command| <smooth-command| <arc-command<move-command= move <command-end-point<line-command= line <command-end-point<horizontal-line-command= hline
[ to [ <length-percentage| left | center | right | x-start | x-end ]
| by <length-percentage] <vertical-line-command= vline
[ to [ <length-percentage| top | center | bottom | y-start | y-end ]
| by <length-percentage] <curve-command= curve
[ [ to <positionwith <control-point[ / <control-point]? ]
| [ by <coordinate-pairwith <relative-control-point[ / <relative-control-point]? ] ] <smooth-command= smooth
[ [ to <position[ with <control-point]? ]
| [ by <coordinate-pair[ with <relative-control-point]? ] ] <arc-command= arc <command-end-point[ [ of <length-percentage{1,2} ]
&& <arc-sweep? && <arc-size? && [rotate <angle]? ] <command-end-point= [ to <position| by <coordinate-pair] <control-point= [ <position| <relative-control-point] <relative-control-point= <coordinate-pair[ from [ start | end | origin ] ]? <coordinate-pair= <length-percentage{2} <arc-sweep= cw | ccw <arc-size= large | small
So instead of somewhat obtuse single-letter commands in the path syntax, these have more understandable names. Here’s an example again from the spec that draws a speech bubble shape: .bubble {
clip-path:
shape(
from 5px 0,
hline to calc(100% - 5px),
curve to right 5px with right top,
vline to calc(100% - 8px),
curve to calc(100% - 5px) calc(100% - 3px) with right calc(100% - 3px),
hline to 70%,
line by -2px 3px,
line by -2px -3px,
hline to 5px,
curve to left calc(100% - 8px) with left calc(100% - 3px),
vline to 5px,
curve to 5px top with left top
);
}
You can see the rounded corners being drawn there with literal curve commands. I think it’s neat. So again Trys’ shapes could be drawn with this once it has more proper browser support. I love how with this syntax we can mix and match units, we could abstract them out with custom properties, we could animate them, they accept readable position keywords like “right”, we can use calc(), and all this really nice native CSS stuff that path() wasn’t able to give us. This is born in a responsive web design world.

Very nice win, web platform.

8 Fun Facts About AI You Didn't Know!
AI can dream – Google’s DeepDream turns normal photos into trippy dreamscapes!

It beat a Go world champion – AlphaGo defeated Lee Sedol in 2016, a historic moment in AI.

It creates art & music – AI can draw, paint, compose, and even sing!

It writes code – Tools like ChatGPT and Copilot help programmers (or do it all).

It finds new medicine – AI helped discover Halicin, a powerful antibiotic.

Voice cloning? Yes! – AI can mimic your voice from just a few seconds of audio.

It trains by gaming – AI learns strategy by playing games like Dota 2 or Minecraft.

It doesn't really “understand” – AI predicts patterns; it doesn’t think like humans.
Which one surprised you the most?

#AI #InterestingFacts #TechNews #FunFacts #ArtificialIntelligence

Smartphones and Microphones: Who Might Be Listening to You?

(*A must-know reality!)

Today, many people are concerned that their smartphones might be secretly recording their conversations.
This is not just a rumor — it’s technically possible, and in some cases, it is actually happening.
The Reality:

Special spyware can activate your microphone without your permission.

Some telecom companies and device manufacturers may allow hidden access to microphones and cameras, sometimes cooperating with government agencies.

Advanced "zero-click" exploits can take over your device without you clicking anything.

Officially:

Under normal conditions, apps must request your permission to access the microphone.

However, through sophisticated attacks, malicious apps, or system-level backdoors, recording without permission is possible.

How to Protect Yourself:

Always keep your device updated.

Avoid installing suspicious apps.

Regularly monitor which apps have microphone and camera access.

Use trusted security apps to detect spyware.

Iossible, physically block the microphone and camera.

Essential HTML Guide

(Short, Clear, Powerful!)

Must-Know Tags:

<h1> to <h6> — Headings
<p> — Paragraph
<a href=""> — Link
<img src="" alt=""> — Image
<ul>, <ol>, <li> — Lists
<div> — Block container
<span> — Inline container
<form> — User input form
<input>, <button>, <textarea>, <select>, <option> — Form elements

Key Attributes:
href — URL for links
src — Image source path
alt — Image description (important for SEO)
class — CSS styling
id — Unique element ID
placeholder — Text hint in form fields

SEO & Accessibility Basics:
Use <title> and <meta name="description"> inside <head>.
Always write alt attributes for images.
Follow correct heading order (<h1> → <h2> → <h3>, etc.)

Quick Best Practices:
Write clean, indented code.
Use semantic tags (<header>, <main>, <footer>) instead of just <div>.
Validate your HTML at validator.w3.org.

HTML is the skeleton of every website. Master it, and you master the web!

Share my html file

CodePen Blog
Chris’ Corner: Reacting

I was listening to Wes and Scott on a recent episode of Syntax talking about RSCs (React Server Components). I wouldn’t say it was particularly glowing.

We use them here at CodePen, and will likely be more and more as we ship more with Next.js, which is part of our most modern stack that we are always moving toward. Me, I like Next.js. React makes good sense to me for use in a very interactive, long-session style application with oodles of state management. By virtue of being on the latest Next.js release, whatever we put in the app directory (“The App Router” as they call it) automatically uses RSCs when it can. I mostly like that. We do have to fight it sometimes, but those fights are generally about server-side rendering and making sure we are set up for that and doing things right to take advantage of it, which honestly we should be doing as much as possible anyway. I’ll also add some anecdotal data that we haven’t exactly seen huge drops in JavaScript bundle size when we move things that direction, which I was hoping would be a big benefit of that work.

But React is more than Next.js, right? Right?! Yes and no. I use React without Next.js sometimes, and we do at CodePen in plenty of places. Without Next.js, usage of RSCs is hard or not happening. Precious few other frameworks are using them, and some have thrown up their hands and refused. To be fair: Parcel has support in Beta and Waku also supports them.

A little hard to call them a big success in this state. But it’s also hard to call the concept of them a bad idea. It’s generally just a good idea to make the servers do more work than browsers, as well as send as little data across the network as possible. If the JavaScript in a React component can be run on the server, and we can make the server part kinda smart, let’s let it?

If you’ve got the time and inclination, Dam Abramov’s React for Two Computers is a massive post that is entirely a conceptual walkthrough abstracting the ideas of RSCs into an “Early World” and “Late World” to understand the why and where it all came from. He just recently followed it up with Impossible Components which gets more directly into using RSCs.

Welp — while we’re talking React lemme drop some related links I found interesting lately.

* React itself, aside from RSCs, isn’t sitting idle. They’ve shipped an experimental <viewtransitioncomponent which is nice to see as someone who has struggled forcing React to do this before. They’ve also shipped an RC (Release Candidate) for the React Compiler (also RC? awkward?). The compiler is interesting in that it doesn’t necessarily make your bundles smaller it makes them run faster.
* Fancy Components is a collection of “mainly React, TypeScript, Tailwind, Motion” components that are… fancy. I’ve seen a bit of pushback on the accessibility of some of them, but I’ve also poked through them and found what look like solid attempts at making them accessible, so YMMV.
* Sahaj Jain says The URL is a great place to store state in React.
* Joshua Wootonn details the construction of a Drag to Select interaction in React which is… pretty complicated.
* The blog Expression Statement (no byline) says HTML Form Validation is heavily underused. I just added a bit of special validation to a form in React this week and I tend to agree. Short story: GMail doesn’t render s where the src has a space in it. 😭. I used pattern directly on the input, and we have our own error message system, otherwise I would have also used setCustomValidity.
* Thoughtbot: Superglue 1.0: React ❤️ Rails

💡 Programming and Microchips: The Digital Duo Behind Modern Tech!

Ever wondered how your phone or computer actually works? At the heart of every smart device are two key elements working together seamlessly.

Let’s break them down:

1️⃣ Microchip (Integrated Circuit): A microchip is like a tiny city made of millions — even billions — of components etched onto a piece of silicon. It’s the “brain” of any electronic device, performing calculations, storing data, and managing operations.

2️⃣ Programming: This is the set of instructions (code) that tells the microchip what to do. Without programming, a chip is just silent hardware. Code gives it purpose — from running your favorite apps to controlling smart devices and enabling AI.

How do they work together?

Microchips provide the processing power and memory (hardware).

Programming gives them intelligence and control (software).
Together, they make possible everything from smartphones and smartwatches to powerful servers and intelligent machines!

Which part of this digital world fascinates you the most? Share your thoughts in the comments!