Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Design Engineering Tip: Most UI animations are built for a single uninterrupted transition. Real users might reverse direction before the animation finishes. Use a spring transition that preserves the element’s current velocity instead of restarting from zero. This keeps rapid hover, press, and state changes smooth and responsive. transition={{...

66,427 Aufrufe • vor 1 Monat •via X (Twitter)

0 Kommentare

Keine Kommentare verfügbar

Kommentare vom Original-Post werden hier angezeigt

Ähnliche Videos

One of the most common mistakes manufacturers make is relying on engineering logic to shape user behavior, while ignoring how users actually feel. Engineers often believe that as long as a feature exists, moves, or looks different, users will appreciate it. Users, however, care about something much simpler: whether the experience feels natural, refined, and intuitive. Great user experience is never created by stacking options. It is created by coherence and emotional consistency. Samsung’s recent update to Lock Star is a clear example. The new version introduces unlock animations that appear to add playfulness, yet the real experience feels disappointing. Many of these animations come across as childish, low level, poorly connected, and mechanically rigid. They feel closer to children’s UI effects than something designed for Samsung’s broad premium user base. The issue is not the presence of animations themselves. The problem lies in the mindset behind them. These effects are clearly driven by implementation logic rather than user perception. The assumption seems to be that adding visual flair automatically creates delight, while ignoring rhythm, emotional tone, and aesthetic maturity. This reflects a long standing pattern in Samsung’s software design. Random stickers, cartoon like emojis, and decorative elements often appear without a cohesive design language. There is a belief that younger users are attracted to these visuals, yet for Gen Z, such elements often feel outdated, immature, and disconnected from a premium identity. Strong product design allows user experience to constrain engineering decisions. When engineering begins to entertain itself, users quietly begin to disengage. Let's see how far apart Samsung and Xiaomi are.

Ice Universe

59,712 Aufrufe • vor 7 Monaten

004/100 Buttons. A bit of the process on building an animation. When looking at a finished animation or in this example a finished button, it can look quite complex inside the CSS. But when building it, it’s more like a lot of simple steps, one after another. Here I had the idea to make some kind of text animation like the footer logo on the Osmo site. I try to add the base animation with no complex easing, for example transition: translate 0.4s ease. Starting with just moving the one text from bottom to top and the other text to top. Adding a stagger, play around with it. Searching for a way to make it more circular. On the research I found the sin() function inside CSS which can build a more smooth non linear curve for the stagger which creates this circular effect. And step by step adding more complexity like, different easing for hover/hover-out, opacity, 3D transform and more. I use also the sin() function to rotate the letters, so the middle ones are getting more rotated than the outer ones. Another thing which helps is to add a small delay on hover, for example 0.05s or 0.1s, you don’t really see the difference, but when you hover pretty fast on and out it doesn’t get that jumpy. I’m using here GSAP’s SplitText to split every char into spans. And then I’m adding a CSS index variable to every span, starting from the center. SplitText can provide CSS index variables, but you cannot tell it from which direction. For the sin() it’s also important to have a max length, so I add another CSS variable with the max char number on it. Crafting 100 Buttons with Osmo ⏳ Total time: 63h

Eduard Bodak

166,023 Aufrufe • vor 4 Monaten

Hold up, here is the prompt: works with almost any model. enjoy :) Role & Objective: Act as an Elite UI/UX Front-End Engineer specializing in Apple-tier micro-interactions and advanced CSS. Your task is to program a perfectly centered navigation bar in a strictly SINGLE HTML file containing all HTML, vanilla CSS, and vanilla JavaScript. No external libraries or frameworks (No Tailwind, React, etc.). Design Concept - "True Liquid Glass": CRITICAL INSTRUCTION: Do NOT generate standard, flat "glassmorphism" or basic frosted glass. I require a physically accurate "Liquid Glass" aesthetic. It must look like wet, poured clear resin, combining the high-gloss specular highlights of classic macOS Aqua with the volumetric spatial depth of modern Apple VisionOS. 1. The Liquid Glass Material & Lighting (CSS): - Deep Refraction: Use `backdrop-filter` with extreme blur (e.g., 50px) and over-saturation (200%). - Specular Highlight: Create a curved, semi-transparent white gradient on the top half using a pseudo-element (`::before`) to simulate a hard light reflection on a wet, rounded 3D surface. - Caustics & Volume: Use multi-layered inner and outer `box-shadow` properties to simulate light refracting at the bottom edge and casting a realistic ambient drop shadow. - Interactive Glare: Implement a soft radial-gradient spotlight inside the glass that dynamically tracks the user's mouse cursor (X/Y coordinates) using JavaScript and CSS variables (`mix-blend-mode: overlay`). 2. Navigation Layout & Elements: - Center the pill-shaped navigation bar perfectly in the middle of the viewport. - Include 3 main navigation items with minimalist, inline SVG stroke icons and text labels: "Home", "Call", and "List". - Add a subtle vertical divider line after the main buttons. - Next to the divider, add a Dark/Light Mode toggle button containing inline SVG Sun and Moon icons. 3. Animations & "Apple Magic": - Sliding Active Pill: Create a solid background "pill" that sits *behind* the active navigation item's text/icon. When a different item is clicked, this pill must dynamically recalculate its width and slide to the new position. - Spring Physics: The sliding transition MUST use an exact Apple-style bouncy spring easing curve (e.g., `transition: all 0.5s cubic-bezier(0.34, 1.2, 0.64, 1)`). - Tactile Feedback: Buttons and icons must physically press down slightly (`transform: scale(0.92)`) when clicked (`:active`). - Theme Switch: The Sun and Moon icons must smoothly rotate, scale, and cross-fade during the transition. 4. Background Environment (Crucial): - Glass needs light and color to refract! Create a full-viewport, smoothly animated mesh gradient background using 3 large, heavily blurred, floating color blobs. - Implement full Dark/Light mode logic using CSS variables (`:root` and `[data-theme="dark"]`). Toggling the theme must seamlessly transition the background blob colors, glass opacity, shadow intensity, and text colors. Output ONLY the pristine, production-ready code. Prioritize maximum visual fidelity and silky-smooth 60fps animations.

Leon Lin

128,501 Aufrufe • vor 5 Monaten

I learned this the hard way: do NOT use SwiftUI if you want your app to look and feel amazing. At least when coding with AI. (sorry, Apple colleagues reading this 😅) I'm sharing my process vibe coding this calorie tracker. I get a lot of questions about the fluid transition in the video. Here's the whole story. Initially, Claude built the grid with SwiftUI. It was quick and easy, and looked good! But the transition to the day view was a boring navigation push/pop. No fun. I wanted something custom. I asked Claude to make it a fluid transition that remaps the food tiles from their source to destination positions. All hell broke loose. Claude tried a bunch of horrible things. Initially it used matched geometry effects, which worked OK but didn't lend themselves well to gesture-driven animations. So it resorted to SwiftUI preference keys + geometry readers to figure out the source and destination positions and calculate the interpolated position based on gesture progress, coordinating across grid and day views. But this meant it had to write a custom layout because it couldn't reposition tiles inside the native SwiftUI grid. And it had to do an awkward handoff between views, which always created ugly pops or jumps. And don't get me started on trying to put it on a bouncy spring, that only made the math 10x buggier. Fortunately, Claude Fable was smart enough to see that this was becoming a disaster (and discover most of the issues itself, in the simulator), so it pivoted away from SwiftUI. Opus might not be so wise, so you'll have to pay attention and intervene. Ultimately, it rewrote it in plain UIKit and everything turned out great. After that, we moved from 2D images to 3D assets, which introduced a new set of performance challenges and yet another rewrite to a single Metal layer, which is what you see below. I can write more about the 2D-to-3D saga if anyone's interested. If I were to do it again, I'd just say "Don't use SwiftUI" from the very first prompt, and save a few hours of headaches. SwiftUI can be amazing for a human iterating directly in code. But agents don't benefit from any of its advantages. Plus, agents have seen decades of UIKit training data, so they're great at writing it, and it's far more flexible. Here's hoping we see more agent-friendly iterations of SwiftUI in the future. Till then, I'm probably going to avoid it.

Anshu

115,013 Aufrufe • vor 2 Monaten

Furniture assembly is the task everyone name-drops and nobody actually attempts at real scale. Every demo I have seen is a scaled down IKEA leg or a single arm on a toy chair. This paper does it properly, real scale, bimanual, up to 7 subtasks and 1,550 control steps per episode, and it is validated on a real Kinova Gen3, not just in sim. That real-robot number is the one that matters: only a 16 percent drop on the hardest task going from simulation to hardware. That is a small enough gap to take seriously, and it did not happen by accident. They built a VR teleoperation rig specifically for coordinated dual-arm collection, because generic single-arm teleop setups do not capture the coordination real assembly needs, and the model predicts a continuous progress signal alongside the action chunk rather than a discrete subtask label, letting it auto-transition and catch drift before it compounds into total failure. The simulation ablation is what got them there, 48 to 80 percent over baselines, with another 21 points from their perception and control design study alone, but that is groundwork, not the headline. Watch the video, there is a clip of the robot misgrasping the seat panel, reopening the gripper, and regrasping on its own. That is not scripted recovery behaviour, it emerged from training, and it emerged on hardware. Excellent work from the team from Mitsubishi Electric Research Laboratories, with Oxford and UNC Chapel Hill Clinical Laboratory Science. Video and project page in comments. #Robotics #Manipulation #VLA

Stephen James

14,952 Aufrufe • vor 2 Monaten