دسته: برنامه‌نویسان

  • Developer Spotlight: Andrea Biason | Codrops

    Developer Spotlight: Andrea Biason | Codrops


    Hi Codrops community! My name is Andrea Biason, and I’m a Creative Frontend Developer currently living in Brescia. I spend my days at Adoratorio Studio, where we create award-winning interactive and immersive experiences by combining strategy, design, and technology.

    Today, I’d like to present four diverse projects that showcase our approach and vision of what a web experience can be.

    The Blue Desert is an R&D project developed to explore new ways of conveying information typically confined to PDFs, such as Global Impact Reports and corporate press releases.

    We strongly believe in the power of storytelling to communicate data that might otherwise be overlooked — yet is truly future-defining — and we wanted to share that with the world.

    The experience presents two narratives:

    • A sci-fi overarching narrative that follows a wanderer’s journey through his devastated world, forever altered by a catastrophic desertification phenomenon.
    • A data-driven narrative revealed through pins scattered across the experience, comparing the Climate Change Goals set by COP21 with the current progress — and shortcomings — we’ve made as a species.

    While creating The Blue Desert, we aimed to maintain an immersive, sand-inspired aesthetic that complemented the narrative and setting — from the color palette to the font choices and design elements. This visual continuity is evident in everything from the smallest icons to the most noticeable transitions, and especially in the brushed, soft, and warm style of the 3D models that define the entire experience.

    The smooth camera movements guiding the user through the various scenes were studied in meticulous detail and often refined throughout the development process.

    We believe that attention to the smallest details is what makes or breaks an immersive experience — and there are many we’re particularly proud of. Each scene offers a unique interaction, such as the rapid flow of a waterfall, the blooming of flowers on tree crowns, or the rejuvenation of the blue desert when touched by the “Komai” blobs.

    When it comes to overall navigation, we’re always struck by the profound, AI-generated voice-over — carefully refined by human hands — paired with the original soundtrack and a rich variety of sound effects tailored to each scene.

    One final element we particularly love is the moment you break through the clouds at the start of the experience and arrive at the wanderer’s campsite. It immediately sets a deeper level of immersion from the very beginning.

    Challenges

    The wanderer’s aphorism at the beginning of the experience reflects the project’s learning journey: “The more we know, the more we realize we don’t know.”

    And that’s exactly what we found ourselves grappling with throughout the creation of this unique digital experience.

    The main challenges we faced included:

    1. 3D challenges: Coordinating multiple scenes in a continuous flow, ensuring smooth navigation, and optimizing exported assets. We also had to manage the project’s large scale — particularly handling cameras, backgrounds, and high-quality textures positioned close to the point of view.
    2. Development challenges: Maintaining a consistent frame rate for users by implementing a dual optimization process for both desktop and mobile, along with leveraging Three.js’ frustum culling. The 3D and development teams worked closely together, experimenting with and implementing InstancedMesh, with a particular focus on Shader Materials and Vertex Shaders.

    Personal Notes

    In terms of R&D, The Blue Desert was definitely the most challenging project we engaged with in recent memory. This isn’t only true in terms of (heavily) expanding our understanding and knowledge of optimization and 3D/WebGL, but also in polishing (and in the beginning, often reworking) the art direction, camera movements, and not falling into the pitfall of “wanting every random idea to make it to the final experience.”

    Given that the project was pretty much carried out in parallel between the 3D and Dev departments, the first phase for both teams consisted of a wide variety of specific experimentations that lasted from a few days to a week, in order to fully master — and then be able to customise to our needs — a variety of technical specifics, from texturing, UV map creation, and modeling, to understanding the shortcomings of optimisation tools like glTF-Transform, as well as specific tests on shaders and animations. The biggest lesson and achievement was definitely structuring (not without hardships) a smoother, more natural collaboration and hand-over process between the two teams.

    Another unexpected outcome, given the unusual pairing of content and approach, was the audiences this experience gathered interest from: initially (and expectedly) from the design community, who enjoyed the story as well as the imaginative world it takes place in, the curated 3D models, and the original themes we produced for the experience. Secondly (and a bit unexpectedly), from many brands that took notice and reached out, finding the approach fresh and engaging as a way to highlight years of efforts in achieving higher sustainability standards.

    Tech Stack

    Vue.js, Three.js, GSAP, Howler.js, Blender

    Ariostea is a brand of Iris Ceramica Group, one of the world’s largest ceramics producers and innovators. What initially started as a simple request for a new corporate website quickly evolved into a complete overhaul of their brand, positioning, and digital presentation.

    The first step in the project was completely revisiting the former sitemap (which consisted of more than 40 first-level pages — a mess we had never seen before), reducing it to eight main pages.

    What makes us particularly proud of this work is the thorough implementation of the brand design elements — most notably the smooth-cornered, rectangular shape of Ariostea’s slabs, which became a cornerstone of the design system — as well as the integration of the client’s PIM to automatically source and update product data, textures, 3D models, and the catalogue.

    While corporate websites generally tend not to stand out as much as WebGL experiences or interactive experiments, we find great satisfaction in crafting well-polished, strategically sound, and functional platforms that — like in Ariostea’s case — will stand the test of time and may serve as a foundation for bolder experiments to follow, as we’ll soon see with ICG Galleries.

    Challenges

    Approaching the design and development for Ariostea, we knew we would face three main challenges. Let’s delve into them one by one:

    The sheer scale of the project

    As mentioned above, the gargantuan amount of information presented on the website proved to be the first challenge. While a careful restructuring streamlined the UI and header — going from 40-something elements (I’m still in disbelief typing this out) to around 8 — the information itself wasn’t going to be deleted. Having longer, richer pages therefore meant creating a more diverse array of modules working in unison, featuring a variety of image and text carousels to better organize the content consumption.

    This was only the first step, as the richest section of the website was (who would’ve thought) the product catalogue — featuring more than 1,500 unique products.

    Our main objective for the “Collections” page was to avoid overwhelming the user with such a diverse selection, which was also arbitrarily divided from a business — not user — perspective. We therefore created a progressive filter system, clearly displayed at the bottom-center, with intuitive options tailored to user needs such as appearance, application, and material size.

    Finding a distinctive element / module / page that would take the project a step further

    While integrating the brand guidelines into the design system as seamlessly as possible, we knew we wanted to design a single page that would set Ariostea apart — something that would act as a memorable visual for all users. That could only be the product page.

    The design we chose to pursue presents an initial, card-like view featuring a texture preview, main data such as description and formats, and a sticky component showcasing the product name, collection, contact CTA, and the option to add the product to a wishlist.

    The texture preview was integrated with a savvy, highly optimized WebGL, generatively sourcing from the client’s PIM and presenting an authentic slab, just like those seen in their showrooms.

    Working in tandem with the brand’s IT to fail-proof the PIM connection

    Given our extensive expertise in custom development and WebGL, as well as modular, consistent productions for corporate websites, the biggest challenge we faced was definitely coordinating and working in tandem with Ariostea’s technical team to smoothly integrate their PIM — a challenge that wasn’t accomplished without a wide range of creative solutions and nerve-wracking brainstorming sessions!

    Personal Notes

    Ariostea was our first time creating custom APIs to connect with the brand’s PIM — something that proved useful later on for developing other, more experiential projects for the group. Additionally, the delicate tuning of multiple animations to achieve a cohesive experience, with a strong focus on UX and content consumption rather than flashy, explosive transitions, was a careful effort that often goes unnoticed.

    Tech Stack

    Vue.js + Nuxt.js, Three.js, GSAP, Blender, WordPress

    Iris Ceramica Group is one of the world leaders in ceramic production, with an ever-growing number of stunning showrooms around the world.

    ICG Galleries are designed to showcase the breadth of the group’s products, brands, and innovations — simulating living environments, presenting new collaborations, and hosting talks and events.

    Formerly represented only on the main company website, the objective of the immersive experience was to present ICG products in a contextualized setting, while also showcasing — through 3D and animations — the wide array of innovations and technologies developed by the company for ceramic surfaces. This idealized version of the Galleries was something the company had long been hoping to achieve digitally.

    Based on three floors that highlight the group’s Values, Products, and Creations, the experience begins with a slider displaying the three isometric floor plans, allowing the user to start their journey freely from whichever floor they find most enticing.

    While isometric views have been used in similar experiences before, for this project we were committed, first, to achieving a distinctive, warm, and refined art direction that embodied the group’s positioning and products — and second, to implementing them directly in the WebGL scene, rather than simply using images.

    Each of the floors presents a custom-designed (and engineered!) space, beautifully adorned with surfaces and interior design elements from ICG — a process that, due to its level of detail, required painstaking shoulder-to-shoulder collaboration with the client. Animations were also created for each of the pins, ranging from simpler ones — like a selection of slabs being highlighted in the Material Library — to more advanced ones, such as the Caveau revealing itself behind the Vault, or a listening room coming to life on the ground floor to showcase the “Hypertouch” technology.

    Given the numerous artistic and design collaborations the Group engages in, we also added a “bonus” floor — the Pop-Up Window — where a new setting or collaboration can be showcased every few months. We like this touch, as it allows the experience to evolve over time, not only in its more information-oriented pages.

    The experience also includes two editorial pages: one showcasing every ICG location around the world, and the other highlighting the events organized at those locations.

    Challenges

    When proposing this project to the client, we knew it was something they hadn’t considered (or even thought possible!) before that moment. We also knew we were asking them to take a leap of faith, to some extent.

    Being launched for the 2025 Milan Design Week (yes, you’re the first ones seeing this!), we’re incredibly proud to show how — through strategy, creative alignment, and close collaboration with the client — truly experiential and visually stunning results can be achieved, even in the B2B space.

    Personal Notes

    The final product we achieved with ICG Galleries is the result of many learnings from previous experiences — particularly in terms of WebGL experimentation — as well as a stable, proven tech stack and a well-oiled collaboration between the Dev and 3D teams.

    Technically speaking, we’re very proud of the smoothness of the camera scrolling, as well as the synchronization of the pins with the 3D environment and its connected HTML overlays.

    What definitely pushed us was adding a variety of animations to every interaction — from the technologies to the living spaces — creating an experience that didn’t feel like a static image, but rather a living, breathing space.

    Tech Stack

    Vue.js + Nuxt.js (SSR), Three.js, GSAP, Blender, WordPress

    Emerging from the politically charged atmosphere of Bologna in the late ’70s, the Intrusion Project serves as a living tribute to Radio Alice — a pioneering force in the free radio movement that sparked a cultural revolution.

    A project born from passion, it features seven audio-reactive shaders designed to amplify the powerful tracks of six genre-defining Italian underground artists, who reinterpreted the recording of the free radio’s final 23 minutes before it was broken into and shut down by police in 1977.

    While designing the Radio Alice experience, we had two certainties. Design-wise, we wanted to reverse our usual approach by inviting members of our creative team who are typically less tied to digital to lead the design — intentionally foregoing recognized (and self-imposed) UI/UX standards in favor of a bolder, grittier experience.

    Conceptually, we wanted to create an incisive moment that spoke directly to the gut of users, but we were also dead set on not letting the design and visuals overshadow the strong, generational narrative the project conveyed.

    The design employs a brutalist aesthetic that emphasizes raw, unpolished elements — mirroring the disruptive nature of the radio station itself — while bringing the archival sounds of Radio Alice to life in a visually dynamic environment.

    By creating a space where users can interact with and connect to the past, the site aims to embed the rebellious spirit of Radio Alice into our collective consciousness. The goal is to leave a trace as indelible as the events of 1977 themselves, encouraging new generations to absorb, reflect, and find inspiration in the courage of those voices.

    Challenges

    The first task for the project was defining a cohesive and scalable art direction for the seven audio-reactive shaders, tackled by our Interaction Designer in collaboration with the creative team. Once we had defined the visuals, the next challenge was transforming the source audio into texture via FFT (Fast Fourier Transform), an algorithm that breaks sound down into its individual frequencies, allowing our visuals to be influenced by a variety of inputs instead of just the combined track.

    As always, when working on the web, optimization was also a key focus — aiming to create the lightest possible shaders that could perform well across all kinds of devices.

    Taking a step back from the technical elements of the website, Radio Alice was one of the first opportunities for our Development team to implement shaders they hadn’t directly developed themselves, leading to a smoother collaboration with our Interaction Designer.

    Personal Notes

    We are particularly proud of the audio-reactive shaders. These not only create a mesmerizing visual experience synced to historical broadcasts but also embody Radio Alice’s chaos and creativity.

    A detail we’d like to highlight is the ability to switch the experience’s color palette between three versions. The reason behind this choice is actually quite simple — and a bit childish: while the iconic red is how we showcase the project and probably the most authentic representation of Radio Alice, the black-and-white and white-on-black versions were just too stunning to leave out!

    Tech Stack

    Vue.js + Nuxt.js, OGL, GSAP, Web Audio Beat Detector

    More about me

    My academic background is anything but related to programming or design. I graduated from a classical high school and chose a university path that combined the worlds of communication, design, and development.

    About 12 years ago, I began my journey at Studio Idee Materia, an independent creative agency in a small town in the province of Venice, with my latest project, Bertani, earning my first SOTD (Site of the Day) on Awwwards.

    For the past 4 years, my path has become more focused on frontend development, since I joined Adoratorio Studio — an independent creative studio known for its drive toward innovation and the creation of deeply branded digital experiences.

    Here, together with Andrea, Daniele, and the entire team, we share daily challenges and a philosophy that we try to convey and bring into the projects we develop.

    Our Philosophy

    It’s a philosophy based on obsessive attention to detail, the desire to always experiment with something new in each project, setting medium- to long-term goals, knowing that nothing is magically achieved overnight, and finally, being aware that the way we implement or approach a problem isn’t always the best one — but it’s the one that suits us best.

    Our Stack

    Depending on the needs of the project at hand, we’ve developed different stacks:

    • The most commonly used stack is based on Vue.js + Nuxt.js + WordPress as the backend. Nuxt is used in both of its variants: SSR mode on a Node.js server, and generate mode deployed via CI/CD on Firebase servers. This stack is used for all corporate projects — especially in generate mode — to meet SEO requirements.
    • For smaller and/or more experimental projects, or those without SEO concerns, we sometimes use a simpler stack that relies on Vite.js.
    • For projects involving 3D, we’ve developed two stacks as well: one using Three.js, and a lighter one using OGL — used when we only need to write shaders without relying on 3D models.

    Looking forward

    As for our current experimentations, we’re still refining our skills in Three.js — particularly in optimization, shader development, and workflow integration with the 3D team.

    Another topic we deeply care about is accessibility, as we believe our projects — however flashy — should be accessible to everyone, without compromise.

    Last but not least, and I felt this needed to be addressed: in such a fast-paced, ever-evolving digital world, we’re continuously finding ways to use AI as a tool to support our creative coding and ideas — not as a jack-of-all-trades meant to replace us.

    Final thoughts

    If you’re a young (or new) developer, my tip is: don’t be afraid to experiment. Today more than ever, technology evolves rapidly and offers infinite possibilities to create new and exciting things. Don’t limit yourself to what you already know — go out and explore uncharted territory.

    When you experiment and try new things, sometimes it may end up like this:

    But a few, precious times, it ends up like this:



    Source link

  • Motion Highlights #4 | Codrops

    Motion Highlights #4 | Codrops


    The

    New

    Collective

    🎨✨💻 Stay ahead of the curve with handpicked, high-quality frontend development and design news, picked freshly every single day. No fluff, no filler—just the most relevant insights, inspiring reads, and updates to keep you in the know.

    Prefer a weekly digest in your inbox? No problem, we got you covered. Just subscribe here.



    Source link

  • Developer Spotlight: Max Barvian | Codrops

    Developer Spotlight: Max Barvian | Codrops


    In past Developer Spotlights, we’ve featured devs who’ve pushed the craft of building award-winning websites. But web development is more than just translating great design—Max Barvian is one of those pioneering devs who have a deep understanding of the core mechanics of frontend development. In 2024, he shared one of the coolest CSS-powered, scroll-driven animations with us here on Codrops. We can’t shine the light enough on Max, as his work represents the next frontier in web development—one that merges deep technical knowledge with creative experimentation.

    Hi! My name is Max Barvian. I’m a UI engineer currently working at Clerk.

    Projects I’m proud of

    NumberFlow

    NumberFlow is an animated number component for React, Vue, Svelte, and vanilla TS/JS. It was heavily inspired by the number animations in the wonderful Family app:

    I built NumberFlow as a custom element with wrapper components for each framework. All the animations are powered by the Web Animations API (WAAPI). It uses the FLIP technique, registered custom CSS properties, spring-based linear() timings, new CSS math functions, and composited KeyframeEffects for better interruption handling.

    The response to NumberFlow has been surreal. 𝕏 is currently using it for their analytics dashboard, and Elon Musk even retweeted this screenshot of it:

    barvian.me

    When it came time to rebuild my portfolio last year, my goal was to make some combination of Godly and the Apple TV home screen. I’d really wanted a site like that for years, with a grid of project videos that smoothly transitioned into detail pages, but never felt confident about pulling it off. Then I found the View Transitions API. Despite its shortcomings (i.e. no interruption handling), it felt like the perfect tool for the job. View Transitions using snapshots of “old” views seemed perfect for the video grid, and meant I wouldn’t have to worry about animating a bunch of <video> elements at the same time. Ultimately, I had to use a few more tricks to get decent performance during the transitions, but I still can’t imagine having built the site with anything else. I was honored when Googlers Addy Osmani and Una Kravets shared my little site as a demo for View Transitions.

    Musée

    I stumbled upon this incredible design by Kevin Pham on Dribbble a couple years ago and immediately fell in love with it. I had wanted to experiment with CSS Scroll Snapping and 3D scenes for a while, and this seemed like the perfect candidate. I ended up using React Three Fiber, Motion for React, and Tailwind to implement it. It’s not perfect (there’s a pesky bug with mobile Safari on the last slide that I haven’t been able to fix), but I’m pretty happy with how it turned out. I was honored when Guillermo Rauch, Paul Henschel, Matt Perry, and Three.js all reposted it.

    Fluid type projects

    This work is probably the most boring on the list but I’m still happy with it. I was working on a Tailwind plugin for CSS clamp() when I encountered some longstanding accessibility issues with fluid type. I didn’t want to bring those issues into my plugin, so I spent a whole Sunday watching math videos on YouTube and talking to my physicist brother to figure out how to work around them. I eventually published the results in Smashing Magazine with some help from their great editors there, and was honored to see Adrian Roselli reference the work in his original article. Utopia, a popular fluid clamp generator, also integrated the findings into their tool.

    About me

    I got into creative development in a 7th grade journalism class, when my teacher made me the webmaster for our school newspaper. I asked my parents for Dreamweaver that year for Christmas and got my first freelance client a year after that. I’ve since moved on from Dreamweaver 🙂, but I’ve never wanted to do anything else professionally. I feel lucky that I’ve been able to make a career out of my passion.

    Current challenges

    At Clerk I’m working on building the component library we use for our dashboard. It’s been a fun challenge to try to build something that equally emphasizes UX and DX! I hope to share more on 𝕏 as it progresses. React Aria Components has been a huge inspiration here.

    Tools

    I basically live in VS Code writing React, Tailwind, and Motion code all day.

    Philosophy

    Someone I follow on 𝕏 thought NumberFlow was a good example of a quote by Charlie Munger:

    “Take a simple idea and take it seriously.”
    —Charlie Munger

    That’s stuck with me over the last few months, and I think it’s increased my enjoyment of projects I previously would’ve dismissed as too routine or boring.

    It’s an honor to be featured on a site I’ve been reading my whole career. Thanks a lot, Manoela and the Codrops team!



    Source link

  • Designer Spotlight: Stephanie Bruce | Codrops

    Designer Spotlight: Stephanie Bruce | Codrops


    Meet Stephanie Bruce, an Independent Designer and Webflow Developer based in London, UK. She has been designing for over 2 years, previously working in Finance. 

    She loves editorial layouts, photography and visually creative web designs. She works closely with agencies and clients worldwide.

    In this spotlight, Stephanie shares a selection of her favorite projects — a window into her creative process, inspirations, and evolution as a designer.

    Featured work

    Valentine

    This is my latest project where I did the art direction, photography direction, web design and development for Freewrite Valentine. The main purpose of the website is to promote their latest Freewrite Valentine, playing tribute to the original Olivetti Valentine typewriter.

    I used retro ads and posters as the main inspiration for the web design and photography direction. We decided to go with a bold red colour throughout the website to emphasise the retro red vibes. I had a two weeks deadline to design and build, as well as photography direction.

    MOD Agency Collab

    A web design project I did at MOD agency, with creative director Matt Jumper. My role was to design the website and create data visuals. It was my first time designing data visuals and I was pretty happy with how fun they turned out. Huge thanks to Mod agency for bringing me along for this project.

    SP28K

    SP28K was an exploration website I did on the Flow Party On Demand course. For this design I decided to explore brutalist design with a touch of editorial layout. This project challenged me to go for a bold approach using expressive typography and high-contrast fonts. Photoshoot of the speaker was done in Spline.

    Concepts and explorations

    Outside of client work, I love spending time creating my own concepts and web design explorations. By creating concept work, I learnt how much I love editorial, photography based websites and how I hope to attract similar work in the near future.

    Especially being a relatively new designer, these concepts have helped me get noticed on social media and led to many opportunities.

    Brief biography and career highlights

    I switched careers from Finance to Design over two years ago. I wanted to find a job that I loved, and once I discovered the world of Digital Design, I became pretty obsessed. I feel like I found my calling.

    When I worked in Finance, I spent a lot of my spare time immersed in the creative world. I would go to exhibitions, galleries, theatre plays, etc. I also studied Photography, which helped me develop an eye for detail and composition. I feel that the combination of my exposure to the arts and my photography skills has played a big role in developing a strong visual eye for design.

    Since changing careers, I’ve had some amazing opportunities to work with leading designers and agencies — from a six-month internship with Fons Mans to collaborations with designers like Dann Petty and Benten Woodring.

    I’ve been freelancing since the beginning of my design career and am very grateful that my work and network have led to multiple collaborations with international clients and agencies.

    Inspiration

    I find that most of my inspiration comes from looking at design outside of web design. I often look at magazine layouts, prints/posters, and branding assets. Exploring these areas challenges me to create things you don’t typically see on websites.

    I also draw a lot of inspiration from visiting art galleries and exhibitions around London, as well as from films and video games like Firewatch and Before Your Eyes.

    Future Goals

    Currently, I’m focused on working with agencies, as I enjoy collaborating and learning as much as possible from them.

    In the near future, I’d love to work with lifestyle and e-commerce clients, and maybe team up with someone to create a purposely small, boutique agency.

    Message to Readers

    Put in the time to practice design, and get comfortable with sharing your work online and networking — it can lead to so many opportunities and collaborations.

    I’d also say it’s totally fine to explore different skills at the beginning, but I recommend committing to mastering one or two that truly excite you. Stay open to learning and keep pushing yourself to improve, no matter how many years of experience you have.

    Feel free to reach out to me on Twitter or Instagram — whether you have a project in mind or just want to grab a coffee, in person or online!





    Source link

  • Droip: The Next Big Revolution in WordPress – Redefining No-Code Web Building

    Droip: The Next Big Revolution in WordPress – Redefining No-Code Web Building


    Let’s be real—building a WordPress site with traditional page builders can feel like assembling IKEA furniture with missing pieces.

    You install a page builder only to find out it doesn’t do half the things you need. So you pile on plugins to fill the gaps, and they end up conflicting with one another.

    Your site slows down, SEO takes a hit, and suddenly, you’re knee-deep in subscription fees, support tickets, and messy workarounds.

    It’s 2025. We deserve better. 

    That era of outdated page builders and plugin-heavy setups is over.

    Today’s web demands speed, flexibility, and full creative control—minus the bloat and the added costs. That’s where Droip comes in. A new kind of builder made for modern creators. 

    But what makes it unique? Let’s break it down.

    All-in-One Web Building Ecosystem 

    Droip is a full-fledged, no-code ecosystem that lets you build smarter.

    Whether it’s SEO, forms, popups, dynamic content, or even image editing, Droip handles it natively.

    Because it’s all native, your site stays lean, fast, and conflict-free. Oh, and your wallet? It stays happy too.

    What that means for you:

    • No surprise costs or upgrade traps.
    • Faster load times and better performance.
    • One support team, one solution.
    • Scales with your business—whether you’re a solo creator or running a full agency.

    Pricing: It’s transparent, with no hidden upsells. Check the Pricing page for the details.

    To learn how Droip works, watch a quick video overview of Droip in action. 

    Modern UI With Maximum Control

    Let’s start with the UI. 

    The moment you open the editor, everything feels intuitive.

    It’s sleek. It’s modern. It’s not that stiff, clunky layout you’ve seen in other WordPress builders. 

    Instead, the editor gives you an interface that feels familiar, like the modern major web builders you already know, but packs the kind of power only Droip can deliver.

    Everything’s exactly where you expect it to be. 

    The menu panels are clean and concise. Element settings are instantly accessible.

    The UX flows effortlessly from dragging elements to switching panels, it’s all frictionless.

    And yes, it also has both dark and light modes for your comfort.

    Overall, it provides a clean, smooth workspace designed to help you move fast and build without barriers.

    Design Freedom For Everyone

    When it comes to design, Droip hands you the keys to total design freedom.

    Whether you’re starting from scratch or using predesigned layouts, you have all the flexibility and options.

    A Growing Collection of Stunning Templates

    Start with Droip’s growing collection of stunning templates, from sleek portfolios to bold business sites. They’re professionally designed, fully customizable, and included in your subscription (no sneaky extra fees)!  

    Pre-Made Sections, Pages, and Components

    Mix and match ready-made sections, pages, and components like contact forms, testimonials, cards, and more. It’s like having a design toolkit at your fingertips. Just drag, drop, customize if needed, and you’re all set.

    Turn Figma Designs into Fully Editable Pages—In Seconds

    Imagine dragging in your Figma mockup and watching it become a live, editable page in seconds. If you have got your site designed in Figma, you can just copy and paste it into Droip—yes, literally. 

    The builder instantly converts it into a fully editable, auto-responsive page with a single click. And the best part? It automatically adapts to all breakpoints, including any custom ones you define.

    Want to Start from Scratch? Go for It!

    If you’re the “I want full control” type, Droip’s intuitive drag-and-drop canvas is all yours. Build pixel-perfect layouts, experiment, and make it yours.

    Droip was built with the atomic approach to give you granular control over every aspect of your website. With deep element editing, you can adjust every detail, from typography to layouts, to fit your exact vision.

    Native Dynamic Content. No ACF Required.

    Managing dynamic content in WordPress usually means extra plugins like ACF. Not anymore.

    Droip lets you create, manage, and style dynamic content like listings, directories, and portfolios right out of the box. 

    Connect your content, customize it visually, and even set dynamic SEO for every item’s detail page. All built-in and all visual.

    A Smarter Media Manager That Works Like a Design Tool

    Droip’s media manager is not just for organizing images.

    You can crop, resize, add filters, or create custom text paths all inside Droip’s powerful native media manager.

    Image Editing Tools

    One of the standout features of Droip’s media manager is its advanced image editing capabilities. 

    Edit your images directly within Droip, from basic cropping and resizing to applying advanced filters, without relying on third-party tools. 

    Text Path Creation

    Another innovative feature is the ability to create text paths. This allows you to design text that follows any path or shape for that extra creative edge.

    Extensive Icons & Shapes library

    Droip has an extensive library of shapes so you can do more than ever. 

    You can leverage an array of distinctive shapes, customize them to create unique visuals, and effortlessly add them to any part of your website.

    Plus, it also houses a vast collection of high-quality icons, all ready to be refined to perfection.

    Instant Global Styling Sync with Variables 

    Most builders make global styling difficult with scattered controls. But this WordPress builder has a dedicated feature called Variables that allows you to save and apply reusable styles across your entire site. 

    The system is centralized and features a real-time preview, meaning you can update your design in seconds. Say you want to tweak your brand’s primary color. Change it once, and Droip updates every button, heading, and section styled with that variable instantly.

    You can also create multiple styling modes, such as light and dark themes, and switch between them with a single click—perfect for seasonal refreshers or theme updates.

    Reusable Components with Symbols

    Droip also comes with a feature called Symbols, which lets you turn any element along with all of its nested children into a reusable component.

    That means if you build something once like a button, a pricing card, or even an entire section, you can reuse it throughout the site

    You can even set your global header and footer as Symbols, which makes keeping everything consistent across your site way easier.

    Immersive Interactions and Animations

    If you have been settling for basic motion, a few hover effects, maybe a fade-in or two, it’s time to achieve more. 

    Droip has rich interactions and animation capabilities. You can create immersive, responsive experiences that feel polished and purposeful—not just flashy. From hover effects to scroll-based reveals, you’re free to build any web interactions.

    And when you’re ready to go beyond simple effects, it has an interaction timeline that gives you a visual playground to choreograph complex, multi-step animations with ease. Paired with the custom timing editor, you can shape how your animation flows down to the finest detail.

    Text Animations

    It also approaches Text Animations with the same depth and flexibility. You can choose your trigger, select transition styles, and animate at the character, word, or element level. 

    You can fine-tune every movement, like speed, direction, intensity, delay, and duration, until it’s just right.

    Multiple Backgrounds & Effects

    Droip offers robust options for layering multiple backgrounds and shadow effects. 

    You can layer multiple backgrounds from solid colors to gradients (linear, radial, conic) or images for dynamic, vibrant designs. 

    Combine that with shadow effects for added depth and dimension, and you can create a truly unique visual experience without being limited by pre-set templates.

    Droip Apps for Seamless Integrations

    Droip has a convenient approach when it comes to connecting integrations. 

    You can directly install and connect third-party integrations without leaving the builder and automate workflows by integrating essential tools like analytics, email marketing, and customer support.

    Native Pop-up Builder

    The built-in popup builder also checks all the right boxes, giving you full control over both design and behavior. 

    Design your pop-ups visually, set visibility conditions, and choose custom triggers, whether it’s a click, scroll, or exit intent. You can position them exactly where you want on the screen.

    But that’s not all. You can also customize the appearance with smooth transitions, whether it’s a subtle notification or a full-screen takeover.

    Form Builder with Built-in Form Data Manager

    Creating forms elsewhere can be a hassle, requiring multiple tools to manage both form design and data collection.

    But with this no-code website builder, you can practically design any web form and then access and manage form data with the built-in Form Data Manager. 

    Whether you’re collecting leads, registrations, or feedback, Droip combines form creation and data management in one place.

    Unlimited Breakpoints for Responsiveness 

    Many builders limit your ability to adjust responsiveness across devices, leaving you with only a few pre-set breakpoints.

    Here, however, you can define unlimited breakpoints and fine-tune responsiveness for every screen size, ensuring your design adapts perfectly.

    AI-Powered Website Creation

    Droip also has AI features to assist and accelerate your entire workflow. 

    You can instantly generate page structures and layouts, all with a single prompt. It intelligently understands your content and automatically creates optimal layouts, which are neatly structured and easily accessible in the Layers Panel. 

    And if you need help crafting the perfect copy, it can do that too. It even generates meta titles and descriptions, saving you time while ensuring your site stays optimized for search engines.

    Role Manager

    Another essential feature for managing your website is the Role Manager.

    With the Role Manager in Droip, you can control what users can access and edit within the Droip Editor.

    Whether you’re working solo or collaborating with a team, Droip lets you customize who has access to what in a pretty straightforward way.

    Accessibility Built-in

    Accessibility is often left to external plugins in other platforms. But Droip bakes it right into the experience.

    From increasing text size and reducing motion to enabling larger cursors and magnifying content, the builder offers a wide range of built-in tools to offer an inclusive website creation experience. It also includes support for various visual impairments, like color blindness. 

    It also has a built-in color contrast checker to ensure that your text is readable and your color choices meet accessibility standards. 

    Dynamic and AI-Powered SEO

    For SEO, you get the basics: meta titles, descriptions, and Open Graph tags, all easily editable for every page. Even better, you can generate SEO metadata automatically with AI, saving you time.

    But when working with dynamic content, Droip takes SEO a step further. 

    You can set dynamic SEO, so you don’t have to write SEO data for every single dynamic detail page. Whether it’s a product catalog or course listings, dynamic SEO optimizes the individual detail pages automatically, saving you from manual updates.

    No Performance Compromise

    With so many powerful features built into the platform, you might wonder if performance takes a hit. 

    But no.

    While other traditional WordPress page builders produce bloated code or excessive scripts, Droip delivers clean, minimal markup so even the most complex site loads fast and smooth.

    Automatic Page Audit for Quality Control

    Most platforms leave quality control up to you.

    But Droip has a Page Audit feature that automatically catches issues before they become problems. 

    Whether it’s missing alt text, links, or class names, you’ll get a clear report so you can publish with confidence.

    Final Verdict

    With its packed feature set, slick UI, and native performance, it’s clear that Droip is a complete powerhouse solution at an unbeatable price.

    It’s sleek, it’s powerful, and it’s exactly what WordPress has been waiting for. 

    Where other builders hit their limits, Droip puts you in the driver’s seat, giving you the freedom and tools to craft extraordinary websites.

    So, if you’re still patching plugins together and wasting your money, it’s time to try Droip to feel the difference.



    Source link

  • Designing for Flow, Not Frustration: The Transformation of Arts Corporation Through Refined Animation

    Designing for Flow, Not Frustration: The Transformation of Arts Corporation Through Refined Animation


    You know what they say about playing sounds on a website: don’t. Autoplaying audio is often considered intrusive and disruptive, which is why modern web practices discourage it. However, sound design, when used thoughtfully, can enhance the user experience and reinforce a brand’s identity. So when Arts Corporation approached me to redesign their website with a request to integrate audio, I saw an opportunity to create an immersive experience that complemented their artistic vision.

    To ensure the sound experience was as seamless as possible, I started thinking about ways to refine it, such as muting audio when the tab is inactive or when a video is playing. That focus on detail made me wonder: what are some other UX improvements that are often overlooked but could make a significant difference? That question set the foundation for a broader exploration of how subtle refinements in animation and interaction design could improve the overall user experience.

    When an Idea is Good on Paper

    The client came in with sketches and a strong vision for the website, including a key feature: “construction lines” overlaid across the design.

    These lines had to move individually, as though being “pushed” by the moving cursor. While this looked great in concept, it introduced a challenge: ensuring that users wouldn’t become frustrated when trying to interact with elements positioned behind the lines. 

    After some testing and trying to find ways to keep the interaction, I realized a compromise was necessary. Using GSAP ScrollTrigger, I made sure that when sections including buttons and links became visible, the interactive lines would be disabled. In the end, the interaction remained only in a few places, but the concept wasn’t worth the frustration.

    Splitting Text Like There’s No Tomorrow

    Another challenge in balancing animation and usability was ensuring that text remained readable and accessible. Splitting text has become a standard effect in the industry, but not everyone takes the extra step to prevent issues for users relying on screen readers. The best solution in my case was to simply revert to the original text once the animation was completed. Another solution, for those who need the text to remain split, would be using aria-label and aria-hidden.

    <h1 aria-label="Hello world">
      <span aria-hidden="true">
        <span>H</span>
        <span>e</span>
        <span>l</span>
        <span>l</span>
        <span>o</span>
      </span>
      <span aria-hidden="true">
        <span>W</span>
        <span>o</span>
        <span>r</span>
        <span>l</span>
        <span>d</span>
      </span>
    </h1>

    This way the user hears only the content of the aria-label attribute, not the text within the element.

    Scroll-Based Disorientation

    Another crucial consideration was scroll-based animations. While they add depth and interactivity, they can also create confusion if users stop mid-scroll and elements appear frozen in unexpected positions.

    Example of scroll-based animation stopped between two states
    Example of a scroll-based animation stopped between two states

    To counter this, I used GSAP ScrollTrigger’s snap feature. This ensured that when users stopped scrolling, the page would snap to the nearest section naturally, maintaining a seamless experience.

    Arrays Start at 5?

    Autoplaying sliders can be an effective way to signal interactivity, drawing users into the content rather than letting them assume it’s static. However, they can also create confusion if not implemented thoughtfully. While integrating the site, I realized that because some slides were numbered, users might land on the page and find themselves on the fifth slide instead of the first, disrupting their sense of flow.

    To address this, I set sliders to autoplay only when they entered the viewport, ensuring that users always started at the first slide. This not only maintained consistency but also reinforced a structured and intuitive browsing experience. By making autoplay purposeful rather than arbitrary, we guide users through the content without causing unnecessary distractions.

    Transition Confusion

    Page transitions play a crucial role in maintaining a smooth, immersive experience, but if not handled carefully, they can lead to momentary confusion. One challenge I encountered was the risk of the transition overlay blending with the footer, since both were black in my design. Users would not perceive a transition at all, making navigation feel disjointed.

    To solve this, I ensured that transition overlays had a distinct contrast by adding a different shade of black, preventing any ambiguity when users navigate between pages. I also optimized transition timing, making sure animations were fast enough to keep interactions snappy but smooth enough to avoid feeling abrupt. This balance created a browsing experience where users always had a clear sense of movement and direction within the site.

    I Can Feel a Shift

    A common issue in web development that often gets overlooked is the mobile resize trigger that occurs when scrolling, particularly when the browser’s address bar appears or disappears on some devices. This resize event can disrupt the smoothness of animations, causing sudden visual jumps or inconsistencies as the page shifts.

    To tackle this, I made sure that ScrollTrigger wouldn’t refresh or re-trigger its animations unnecessarily when this resize event occurred by turning on ignoreMobileResize:

    ScrollTrigger.config({
       ignoreMobileResize: true
     });

    I also ensured that any CSS or JavaScript based on viewport height would not be recalculated on a vertical resize on mobile. Here’s a utility function I use to handle resize as an example: 

    /**
     * Attaches a resize event listener to the window and executes a callback when the conditions are met.
     * 
     * @param {Function} callback - The function to execute when the resize condition is met.
     * @param {number} [debounceTime=200] - Time in milliseconds to debounce the resize event.
     */
    function onResize(callback, debounceTime = 200) {
      let oldVh = window.innerHeight;
      let oldVw = window.innerWidth;
      const isTouchDevice = 'maxTouchPoints' in navigator && navigator.maxTouchPoints > 0;
    
      // Define the resize handler with debounce to limit function execution frequency
      const resizeHandler = $.debounce(() => {
        const newVh = window.innerHeight;
        const newVw = window.innerWidth;
    
        /**
         * Condition:
         *  - If the device is touch and the viewport height has changed significantly (≥ 25%).
         *  - OR if the viewport width has changed at all.
         * If either condition is met, execute the callback and update old dimensions.
         */
        if ((isTouchDevice && Math.abs(newVh - oldVh) / oldVh >= 0.25) || newVw !== oldVw) {
          callback();
          oldVh = newVh;
          oldVw = newVw;
        }
      }, debounceTime);
    
      // Attach the resize handler to the window resize event
      $(window).on('resize', resizeHandler);
    }

    Copy That! Rethinking Contact Links

    It was the client’s request to have a simple contact link with a “mailto” instead of a full contact page. While this seemed like a straightforward approach, it quickly became clear that mailto links come with usability issues. Clicking one automatically opens the default email app, which isn’t always the one the user actually wants to use. Many people rely on webmail services like Gmail or Outlook in their browser, meaning a forced mail client launch can create unnecessary friction. Worse, if the user is on a shared or public computer, the mail app might not even be configured, leading to confusion or an error message.

    To improve this experience, I opted for a more user-friendly approach: mailto links would simply copy the email to the clipboard and display a confirmation message. 

    The Takeaway

    This project reinforced the importance of balancing creativity with usability. While bold ideas can drive engagement, the best experiences come from refining details users may not even notice. Whether it’s preventing unnecessary animations, ensuring smooth scrolling, or rethinking how users interact with contact links, these small decisions make a significant impact. In the end, great web design isn’t just about visuals, it’s about crafting an experience that feels effortless for the user.



    Source link

  • Mastering Carousels with GSAP: From Basics to Advanced Animation

    Mastering Carousels with GSAP: From Basics to Advanced Animation


    Carousels are a fairly common UI pattern (there are many excellent carousel and slider examples available on Codrops). While carousel designs vary depending on the use case, the following demos explore how the GreenSock Animation Platform (GSAP) can be used to achieve seamless looping, smooth animations, and ultimately, a better user experience.

    This article is for frontend designers and developers interested in enhancing the functionality and visual appeal of a standard horizontal carousel. Familiarity with JavaScript and basic GSAP methods will be helpful, but anyone looking for inspiration and practical examples may find the following content useful.

    What You’ll Learn

    • Basic carousel implementation using HTML and CSS
    • How to use gsap.utils.wrap() and horizontalLoop()
    • Advanced animation techniques, including image parallax and function-based values

    Our Basic Carousel

    Let’s start with a horizontally scrolling carousel using only HTML and CSS:

    <div class="carousel">
        
        <div class="carousel-slide">
          <img src="https://images.unsplash.com/photo-1659733582156-d2a11801e59f?q=50&w=1600">
          <h2>We're No</h2>
          <h5>Strangers to love</h5>
        </div>
            
        ...
    
    </div>
    .carousel {
      width: 100vw;
      height: 80vh;
      gap: 10px;
      overflow-x: auto;
      scroll-snap-type: x mandatory;
      display: flex;
      -webkit-overflow-scrolling: touch;
    }
    
    .carousel-slide {
      position: relative;
      flex: 0 0 50%;
      display: flex;
      flex-direction: column;
      justify-content: center;
      align-items: center;
      color: white;
      scroll-snap-align: center;
      overflow: hidden;
    }
    
    .carousel-slide img {
      position: absolute;
      width: 100%;
      height: 100%;
      object-fit: cover;
    }
    
    h2 {
      position: relative;
      margin: 0;
      font-size: 1.8rem;
    }
    
    h5 {
      position: relative;
      margin: 2% 0 0 0;
      font-size: 1rem;
      font-weight: 100;
      letter-spacing: 0.3px;
    }
    
    /* Simplify the scroll bar appearance */
    ::-webkit-scrollbar {
      height: 13px;
    }
    
    ::-webkit-scrollbar-track {
      background: transparent;
    }
    
    ::-webkit-scrollbar-thumb {
      border-top: 6px solid #000;
      background: #555;
      width: 50%;
    }
    
    ::-webkit-scrollbar-thumb:hover {
      background: #bbb;
    }
    
    @media (max-width: 500px) {
      .carousel-slide {
        flex: 0 0 80%;
      }
    
      ::-webkit-scrollbar-thumb {
        width: 80%;
      }
    }

    Here’s the result:

    It uses scroll snapping and some custom styling on the scrollbar. Nothing fancy, but it works even when JavaScript is disabled.

    Note that the HTML above is intentionally concise. However, in production, it’s important to follow accessibility best practices, including using alt text on images and descriptive ARIA attributes for screen reader users.

    Building on the Foundation – GSAP Demo 1A

    To see how GSAP can enhance a carousel, we’ll explore two different approaches—the first using gsap.utils.wrap(). Wrap is one of several handy utility methods included in gsap.js—no plugin required! Given a min/max range, it returns a value within that range:

     gsap.utils.wrap(5, 10, 12); // min 5, max 10, value to wrap 12: returns 7

    The example above returns 7 because 12 is 2 more than the maximum of 10, so it wraps around to the start and moves 2 steps forward from there. In a carousel, this can be used to loop infinitely through the slides.

    Here’s a simple demo of how it can be applied:

    In the HTML, a <nav> block has been added that contains previous/next buttons and progress text:

    <nav class="carousel-nav">
      <button class="prev" tabindex="0" aria-label="Previous Slide"></button>
      <button class="next" tabindex="0" aria-label="Next Slide"></button>
      <div>1/8</div>
    </nav>

    A few new rules have been added to the CSS, most importantly to .carousel-slide-abs:

    .carousel-slide-abs {
      position: absolute;
      left: 50%;
      top: 50%;
      transform: translate(-50%, -50%);
      width: 75vw;
      height: 70vh;
    }

    In the JS, we override the carousel’s scroll-snap-type and display the <nav> block. Since we no longer have a scrollable area, the buttons are necessary to maintain keyboard accessibility. Safari requires tabindex="0" to allow users to tab to them. Additionally, aria-labels are important since the buttons have no visible text content.

    We apply the new class to each slide, which effectively stacks them all in the center. We also set the initial opacity: 1 for the first slide and 0 for the rest:

    gsap.set(".carousel", { "scroll-snap-type": "none" });
    
    gsap.set(".carousel-nav", { display: "block" });
    
    slides.forEach((slide, i) => {
      slide.classList.add("carousel-slide-abs");
      gsap.set(slide, { opacity: (i === 0 ? 1 : 0) });
    });

    Next, we need a function that transitions to the previous or next slide. changeSlide() is passed a direction parameter of either positive or negative 1. Inside this function, we:

    1. Fade out the current slide
    2. Update the current slide index using gsap.utils.wrap()
    3. Fade in the new current slide
    4. Update the progress text

    The different easing on the outro and intro tweens helps prevent excessive overlapping opacity during the crossfade.

    next.addEventListener("click", () => changeSlide( 1 ));
    prev.addEventListener("click", () => changeSlide( -1 ));
    
    function changeSlide( dir ) {
      
      gsap.to(slides[currentIndex], { opacity: 0, ease: "power3" });
      
      currentIndex = gsap.utils.wrap(0, slides.length, (currentIndex += dir));
      
      gsap.to(slides[currentIndex], { opacity: 1, ease: "power3.inOut" });
      
      gsap.set(".carousel-nav div", { innerText: `${currentIndex + 1}/${slides.length}` });
    
    }

    Polishing the Transition – GSAP Demo 1B

    To take this idea further, let’s add more detail to the outro and intro animations:

    For the 3D perspective to work, we’ve added perspective: 750px to .carousel-slide-abs in the CSS.

    Instead of targeting the slides themselves, we set the opacity of their child elements to 0—except for those in the first slide.

     gsap.set(slide.children, { opacity: (i === 0 ? 1 : 0) });

    Then, we do the following inside changeSlide():

    1. Store a reference to the outgoing slide’s children
    2. Update currentIndex, just as before
    3. Create a const for the incoming slide’s children
    4. Kill tweens on both slides’ children to prevent conflicts if slides change rapidly
    5. Create a timeline for the transition:
    gsap.timeline({ defaults:{ ease: "expo" } })
      // update progress text
      .set(".carousel-nav div", { innerText: `${currentIndex + 1}/${slides.length}` })
    
      // old slide outro
      .to(oldLayers[0], {
        duration: 0.3,
        rotateY: (dir<0 ? -75 : 75),
        scale: 0.6,
        ease: "power2.in"
      }, 0)
      .to(oldLayers, {
        duration: 0.3,
        opacity: 0,
        ease: "power2.in"
      }, 0)
    
      // new slide intro
      .to(newLayers, {
        opacity: 1,
        ease: "power1.inOut",
        stagger: 0.2
      }, 0.2)
      .fromTo(newLayers[0], {
        rotateY: (dir<0 ? 90 : -90),
        scale: 0.6
      },{
        rotateY: 0,
        scale: 1
      }, 0.3)
      .fromTo([newLayers[1], newLayers[2]], {
        y: 35
      },{
        duration: 1,
        y: 0,
        stagger: 0.14
      }, 0.4);

    Easing and staggers help smooth out and space the movement. The dir parameter modifies the rotationY, adding a subtly unique motion to previous and next actions.

    This basic setup can be easily customized further. Animating a clip-path, applying a blur filter, or experimenting with additional 3D transforms could all produce interesting results.

    A Different Approach – GSAP Demo 2A

    Another way to create a seamless looping carousel with GSAP is to use the horizontalLoop() helper function. Although GSAP helper functions aren’t officially part of the core library, they’re a handy collection of code snippets and shortcuts. They also serve as great learning resources for writing more advanced GSAP code.

    This specific helper function animates elements along their x-axis and repositions them once they’re out of view to create an infinite loop. Here’s a basic implementation:

    Again, we override the CSS and display the <nav> element. Then we call horizontalLoop(), which takes two parameters: an array of the carousel slides and a config object for setting various options.

    const loop = horizontalLoop(slides, {
      paused: true,       // no auto-scroll
      paddingRight: 10,   // match the 10px flex gap
      center: true,       // snap the active slide to the center
      onChange: (slide, index) => { // called when the active slide changes
        if (activeSlide) {
          gsap.to(".active", { opacity: 0.3 });
          activeSlide.classList.remove("active");
        }
        slide.classList.add("active");
        activeSlide = slide;
        gsap.to(".active", { opacity: 1, ease: "power2.inOut" });
        gsap.set(".carousel-nav div", { innerText: `${index + 1}/${slides.length}` });
      }
    });

    The most notable of these options is the onChange callback, where we can write code that executes each time the active slide changes. In this example, we’re removing and adding the “active” class name and tweening the opacity to draw more focus to the center slide.

    The helper function returns a timeline with several useful added methods, including next(), previous(), and toIndex(). We’ll use these to add navigation functionality to our previous/next buttons, as well as to the individual slides:

    next.addEventListener("click", () => loop.next({ duration: 1, ease: "expo" }));
    prev.addEventListener("click", () => loop.previous({ duration: 1, ease: "expo" }));
    
    // each slide can function as a button to activate itself
    slides.forEach((slide, i) => {
      slide.addEventListener("click", () => loop.toIndex(i, {duration: 1, ease: "expo"}))
    });

    Finally, we set the initial carousel state by adjusting the opacity of each slide and calling toIndex() with no tween duration, which centers the active slide.

    gsap.set(".carousel-slide", { opacity: (i) => (i === 0 ? 1 : 0.3) });
    
    loop.toIndex(0, { duration: 0 }); 

    If you’re unfamiliar with function-based values in GSAP, this is an amazing feature—definitely check out that link to learn how they work. Here, we’re iterating through each element with the class name “carousel-slide,” returning an opacity value of 1 for the first slide and 0.3 for the rest.

    The remainder of the JS is just the helper function, copied and pasted from the GSAP docs demo. In most cases, you won’t need to modify anything inside it. (We’ll look at an exception in Demo 2C.)

    Add Draggable & InertiaPlugin – GSAP Demo 2B

    To make the carousel move on drag, we’ll need two plugins: Draggable and the Inertia Plugin. Once those scripts are included, you can set draggable: true in the config object.

    In addition to drag behavior, this iteration includes some text animation, with logic to prevent it from running on the first load (plus hover in/out animations on the nav buttons).

    onChange: (slide, index) => { // called when the active slide changes
      if (activeSlide) {
        gsap.to(".carousel h2, .carousel h5", { overwrite: true, opacity: 0, ease: "power3" });
        gsap.to(".active", { opacity: 0.3 });
        activeSlide.classList.remove("active");
      }
      slide.classList.add("active");
      activeSlide = slide;
      
      // intro animation for new active slide
      gsap.timeline({ defaults:{ ease:"power1.inOut" } })
    
        // fade in the new active slide
        .to(".active", { opacity: 1, ease: "power2.inOut" }, 0)
    
        // fade out the progress text, change its value, fade it back in
        .to(".carousel-nav div", { duration: 0.2, opacity: 0, ease: "power1.in" }, 0)
        .set(".carousel-nav div", { innerText: `${index + 1}/${slides.length}` }, 0.2)
        .to(".carousel-nav div", { duration: 0.4, opacity: 0.5, ease: "power1.inOut" }, 0.2)
    
        // fade in the text elements and translate them vertically
        .to(".active h2, .active h5", { opacity: 1, ease: "power1.inOut" }, 0.3)
        .fromTo(".active h2, .active h5", { y:(i)=>[40,60][i] },{ duration: 1.5, y: 0, ease: "expo" }, 0.3)
    
        // skip active slide animation on first run
        .progress( firstRun? 1: 0 )
    }

    Adding Parallax – GSAP Demo 2C

    To make the movement more engaging, let’s calculate each slide’s horizontal progress and use it to create a parallax effect.

    Until now, we haven’t modified the helper function. However, to calculate slide progress, this version includes one change inside horizontalLoop().

    Now, every time the carousel timeline updates, slideImgUpdate() is called. This function sets each image’s xPercent based on the progress of its parent slide. Progress is 0 when the slide is offstage to the left, and 1 when it’s offstage to the right.

    function slideImgUpdate(){
      slides.forEach( slide => {
        const rect = slide.getBoundingClientRect();
        const prog = gsap.utils.mapRange(-rect.width, innerWidth, 0, 1, rect.x);
        const val = gsap.utils.clamp(0, 1, prog );
        gsap.set(slide.querySelector("img"), {
          xPercent: gsap.utils.interpolate(0, -50, val)
        });
      });
    }

    GSAP utility functions mapRange(), interpolate(), and clamp() make the progress calculation much easier. Note, in the CSS, the width of .carousel-slide img is increased to 150%, so there will be enough image for a 50% horizontal movement.

    Taking It Further

    There are endless ways you could build on these demos, customizing both appearance and functionality. A few ideas include:

    • Modify how many slides are shown at once—a single, full-frame version could be interesting, as could several smaller slides to create a cover flow effect. In both of those examples, the progress indicator also became a fun area for experimentation.
    • Additional details could be added by calling custom functions inside the helper function’s onPress, onRelease, or onThrowComplete callbacks. Here’s one more iteration on Demo 2, where the entire carousel shrinks while the pointer is held down.
    • The carousel could even serve as navigation for a separate animated page element, like on Nite Riot.
    • If you want the carousel to respond to mouse wheel movements, GSAP’s Observer plugin offers an easy way to handle those events.
    • With GSAP’s matchMedia(), you can specify different animations for various viewport widths and tailor behavior for users who prefer reduced motion.



    Source link

  • Upgrading a 20 year old University Project to .NET 6 with dotnet-upgrade-assistant

    Upgrading a 20 year old University Project to .NET 6 with dotnet-upgrade-assistant



    I wrote a Tiny Virtual Operating System for a 300-level OS class in C# for college back in 2001 (?) and later moved it to VB.NET in 2002. This is all pre-.NET Core, and on early .NET 1.1 or 2.0 on Windows. I moved it to GitHub 5 years ago and ported it to .NET Core 2.0 at the time. At this point it was 15 years old, so it was cool to see this project running on Windows, Linux, in Docker, and on a Raspberry Pi…a machine that didn’t exist when the project was originally written.

    NOTE: If the timeline is confusing, I had already been working in industry for years at this point but was still plugging away at my 4 year degree at night. It eventually took 11 years to complete my BS in Software Engineering.

    This evening, as the children slept, I wanted to see if I could run the .NET Upgrade Assistant on this now 20 year old app and get it running on .NET 6.

    Let’s start:

    $ upgrade-assistant upgrade .\TinyOS.sln
    -----------------------------------------------------------------------------------------------------------------
    Microsoft .NET Upgrade Assistant v0.3.256001+3c4e05c787f588e940fe73bfa78d7eedfe0190bd

    We are interested in your feedback! Please use the following link to open a survey: https://aka.ms/DotNetUASurvey
    -----------------------------------------------------------------------------------------------------------------

    [22:58:01 INF] Loaded 5 extensions
    [22:58:02 INF] Using MSBuild from C:\Program Files\dotnet\sdk\6.0.100\
    [22:58:02 INF] Using Visual Studio install from C:\Program Files\Microsoft Visual Studio\2022\Preview [v17]
    [22:58:06 INF] Initializing upgrade step Select an entrypoint
    [22:58:07 INF] Setting entrypoint to only project in solution: C:\Users\scott\TinyOS\src\TinyOSCore\TinyOSCore.csproj
    [22:58:07 INF] Recommending executable TFM net6.0 because the project builds to an executable
    [22:58:07 INF] Initializing upgrade step Select project to upgrade
    [22:58:07 INF] Recommending executable TFM net6.0 because the project builds to an executable
    [22:58:07 INF] Recommending executable TFM net6.0 because the project builds to an executable
    [22:58:07 INF] Initializing upgrade step Back up project

    See how the process is interactive at the command line, with color prompts and a series of dynamic multiple-choice questions?

    Updating .NET project with the upgrade assistant

    Interestingly, it builds on the first try, no errors.

    When I manually look at the .csproj I can see some weird version numbers, likely from some not-quite-baked version of .NET Core 2 I used many years ago. My spidey sense says this is wrong, and I’m assuming the upgrade assistant didn’t understand it.

        <!-- <PackageReference Include="ILLink.Tasks" Version="0.1.4-preview-906439" /> -->
    <PackageReference Include="Microsoft.Extensions.Configuration" Version="2.0.0-preview2-final" />
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.0.0-preview2-final" />
    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.0.0-preview2-final" />
    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="2.0.0-preview2-final" />

    I also note a commented-out reference to ILLink.Tasks which was a preview feature in Mono’s Linker to reduce the final size of apps and tree-trim them. Some of that functionality is built into .NET 6 now so I’ll use that during the build and packaging process later. The reference is not needed today.

    I’m gonna blindly upgrade them to .NET 6 and see what happens. I could do this by just changing the numbers and seeing if it restores and builds, but I can also try dotnet outdated which remains a lovely tool in the upgrader’s toolkit.

    image

    This “outdated” tool is nice as it talks to NuGet and confirms that there are newer versions of certain packages.

    In my tests – which were just batch files at this early time – I was calling my dotnet app like this:

    dotnet netcoreapp2.0/TinyOSCore.dll 512 scott13.txt  

    This will change to the modern form with just TinyOSCore.exe 512 scott13.txt with an exe and args and no ceremony.

    Publishing and trimming my TinyOS turns into just a 15 meg EXE. Nice considering that the .NET I need is in there with no separate install. I could turn this little synthetic OS into a microservice if I wanted to be totally extra.

    dotnet publish -r win-x64 --self-contained -p:PublishSingleFile=true -p:SuppressTrimAnalysisWarnings=true

    If I add

    -p:EnableCompressionInSingleFile=true

    Then it’s even smaller. No code changes. Run all my tests, looks good. My project from university from .NET 1.1 is now .NET 6.0, cross platform, self-contained in 11 megs in a single EXE. Sweet.


    Sponsor: At Rocket Mortgage® the work you do around here will be 100% impactful but won’t take all your free time, giving you the perfect work-life balance. Or as we call it, tech/life balance! Learn more.




    About Scott

    Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

    facebook
    bluesky
    subscribe
    About   Newsletter

    Hosting By
    Hosted on Linux using .NET in an Azure App Service










    Source link

  • A Nightscout Segment for OhMyPosh shows my realtime Blood Sugar readings in my Git Prompt

    A Nightscout Segment for OhMyPosh shows my realtime Blood Sugar readings in my Git Prompt



    I’ve talked about how I love a nice pretty prompt in my Windows Terminal and made videos showing in detail how to do it. I’ve also worked with my buddy TooTallNate to put my real-time blood sugar into a bash or PowerShell prompt, but this was back in 2017.

    Now that I’m “Team OhMyPosh” I have been meaning to write a Nightscout “segment” for my prompt. Nightscout is an open source self-hosted (there are commercial hosts also like T1Pal) website and API for remote display of real-time and near-real-time glucose readings for Diabetics like myself.

    Since my body has an active REST API where I can just do an HTTP GET (via curl or whatever) and see my blood sugar, it clearly belongs in a place of honor, just like my current Git Branch!

    My blood sugar in my Prompt!

    Oh My Posh supports configurable “segments” and now there’s a beta (still needs mmol and stale readings support) Nightscout segment that you can setup in just a few minutes!

    This prompt works in ANY shell on ANY os! You can do this in zsh, PowerShell, Bash, whatever makes you happy.

    Here is a YouTube of Jan from OhMyPosh and I coding the segment LIVE in Go.

    https://www.youtube.com/watch?v=_meKUIm9NwA

    If you have an existing OhMyPosh json config, you can just add another segment like this. Make sure your Nightscout URL includes a secure Token or is public (up to you). Note also that I setup “if/then” rules in my background_templates. These are optional and up to you to change to your taste. I set my background colors to red, yellow, green depending on sugar numbers. I also have a foreground template that is not really used, as you can see it always evaluates to black #000, but it shows you how you could set it to white text on a darker background if you wanted.

    {
    "type": "nightscout",
    "style": "diamond",
    "foreground": "#ffffff",
    "background": "#ff0000",
    "background_templates": [
    "{{ if gt .Sgv 150 }}#FFFF00{{ end }}",
    "{{ if lt .Sgv 60 }}#FF0000{{ end }}",
    "#00FF00"
    ],
    "foreground_templates": [
    "{{ if gt .Sgv 150 }}#000000{{ end }}",
    "{{ if lt .Sgv 60 }}#000000{{ end }}",
    "#000000"
    ],

    "leading_diamond": "",
    "trailing_diamond": "\uE0B0",
    "properties": {
    "url": "https://YOURNIGHTSCOUTAPP.herokuapp.com/api/v1/entries.json?count=1&token=APITOKENFROMYOURADMIN",
    "http_timeout": 1500,
    "template": " {{.Sgv}}{{.TrendIcon}}"
    }
    },

    By default we will only go out and hit your Nightscout instance every 5 min, only when the prompt is repainted, and we’ll only wait 1500ms before giving up. You can set that “http_timeout” (how long before we give up) if you feel this slows you down. It’ll be cached for 5 min so it’s unlikely  to b something you’ll notice. The benefit of this new OhMyPosh segment over the previous solution is that it requires no additional services/chron jobs and can be setup extremely quickly. Note also that you can customize your template with NerdFonts. I’ve included a tiny syringe!

    What a lovely prompt with Blood Sugar!

    Next I’ll hope to improve the segment with mmol support as well as strikeout style for “stale” (over 15 min old) results. You’re also welcome to help out by watching our YouTube and submitting a PR!


    Sponsor: Make login Auth0’s problem. Not yours. Provide the convenient login features your customers want, like social login, multi-factor authentication, single sign-on, passwordless, and more. Get started for free.




    About Scott

    Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

    facebook
    bluesky
    subscribe
    About   Newsletter

    Hosting By
    Hosted on Linux using .NET in an Azure App Service










    Source link

  • JavaScript and TypeScript Projects with React, Angular, or Vue in Visual Studio 2022 with or without .NET

    JavaScript and TypeScript Projects with React, Angular, or Vue in Visual Studio 2022 with or without .NET



    I was reading Gabby’s blog post about the new TypeScript/JavaScript project experience in Visual Studio 2022. You should read the docs on JavaScript and TypeScript in Visual Studio 2022.

    If you’re used to ASP.NET apps when you think about apps that are JavaScript heavy, “front end apps” or TypeScript focused, it can be confusing as to “where does .NET fit in?”

    You need to consider the responsibilities of your various projects or subsystems and the multiple totally valid ways you can build a web site or web app. Let’s consider just a few:

    1. An ASP.NET Web app that renders HTML on the server but uses TS/JS
      • This may have a Web API, Razor Pages, with or without the MVC pattern.
      • You maybe have just added JavaScript via <script> tags
      • Maybe you added a script minimizer/minifier task
      • Can be confusing because it can feel like your app needs to ‘build both the client and the server’ from one project
    2. A mostly JavaScript/TypeScript frontend app where the HTML could be served from any web server (node, kestrel, static web apps, nginx, etc)
      • This app may use Vue or React or Angular but it’s not an “ASP.NET app”
      • It calls backend Web APIs that may be served by ASP.NET, Azure Functions, 3rd party REST APIs, or all of the above
      • This scenario has sometimes been confusing for ASP.NET developers who may get confused about responsibility. Who builds what, where do things end up, how do I build and deploy this?

    VS2022 brings JavaScript and TypeScript support into VS with a full JavaScript Language Service based on TS. It provides a TypeScript NuGet Package so you can build your whole app with MSBuild and VS will do the right thing.

    NEW: Starting in Visual Studio 2022, there is a new JavaScript/TypeScript project type (.esproj) that allows you to create standalone Angular, React, and Vue projects in Visual Studio.

    The .esproj concept is great for folks familiar with Visual Studio as we know that a Solution contains one or more Projects. Visual Studio manages files for a single application in a Project. The project includes source code, resources, and configuration files. In this case we can have a .csproj for a backend Web API and an .esproj that uses a client side template like Angular, React, or Vue.

    Thing is, historically when Visual Studio supported Angular, React, or Vue, it’s templates were out of date and not updated enough. VS2022 uses the native CLIs for these front ends, solving that problem with Angular CLI, Create React App, and Vue CLI.

    If I am in VS and go “File New Project” there are Standalone templates that solve Example 2 above. I’ll pick JavaScript React.

    Standalone JavaScript Templates in VS2022

    Then I’ll click “Add integration for Empty ASP.NET Web API. This will give me a frontend with javascript ready to call a ASP.NET Web API backend. I’ll follow along here.

    Standalone JavaScript React Template

    It then uses the React CLI to make the front end, which again, is cool as it’s whatever version I want it to be.

    React Create CLI

    Then I’ll add my ASP.NET Web API backend to the same solution, so now I have an esproj and a csproj like this

    frontend and backend

    Now I have a nice clean two project system – in this case more JavaScript focused than .NET focused. This one uses npm to startup the project using their web development server and proxyMiddleware to proxy localhost:3000 calls over to the ASP.NET Web API project.

    Here is a React app served by npm calling over to the Weather service served from Kestrel on ASP.NET.

    npm app running in VS 2022 against an ASP.NET Web API

    This is inverted than most ASP.NET Folks are used to, and that’s OK. This shows me that Visual Studio 2022 can support either development style, use the CLI that is installed for whatever Frontend Framework, and allow me to choose what web server and web browser (via Launch.json) I want.

    If you want to flip it, and put ASP.NET Core as the primary and then bring in some TypeScript/JavaScript, follow this tutorial because that’s also possible!


    Sponsor: Make login Auth0’s problem. Not yours. Provide the convenient login features your customers want, like social login, multi-factor authentication, single sign-on, passwordless, and more. Get started for free.




    About Scott

    Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

    facebook
    bluesky
    subscribe
    About   Newsletter

    Hosting By
    Hosted on Linux using .NET in an Azure App Service










    Source link