Galileo Glass UI — Version 1.0.27
Craft Interfaces That Feel Alive.
Experience interactions so fluid and natural, they feel instantly familiar. Galileo integrates advanced physics directly into your UI, enabling components that respond with lifelike precision.
Build truly dynamic and engaging applications. Explore a rich ecosystem of components designed for interaction, and unlock ultimate creative freedom with direct access to the core physics simulation.
Physics Animation System
Galileo Glass UI Features
90+ Components Powered By Physics
The Complete Glass UI System
Our revolutionary Physics Animation System brings interfaces to life with spring dynamics, magnetic interactions, constraints, layouts, and precise motion control—all engineered for exceptional performance and seamless accessibility.
Physics-Powered Animation
Experience UI that feels alive with naturally responsive spring dynamics, magnetic interactions, intelligent collision detection, and enhanced event data that responds to every interaction.
79 Glass Components
An expansive suite of specialized Glass components, including the new DataGrid and Stepper, meticulously crafted for stunning visuals and seamless integration.
Sophisticated Glassmorphism
Create breathtaking depth with perfectly calibrated blur, transparency, reflections, and dynamic lighting that adapts to your design language.
Adaptive Performance
Intelligently adjusts to every device with dynamic quality tiers, automatic capability detection, and resource-efficient rendering that ensures fluid 60fps everywhere.
Accessibility Native
Seamlessly honors user preferences with refined motion sensitivity levels, intelligent alternatives, and the new animated GlassFocusRing for clarity.
Direct Physics Engine Control
Unprecedented control through direct access to our integrated physics engine, enabling sophisticated simulations, physics constraints, and enhanced collision data.
Physics-Based Layouts
Effortlessly create dynamic layouts (Grid, Stack, Freeform) driven by physics using the dedicated `usePhysicsLayout` hook.
Ambient Tilt Effect
Subtly respond to user presence by applying a gentle, device-aware tilt effect across elements based on global pointer position.
Modular Charts with Physics
Build flexible data visualizations with our modular chart system, now enhanced with physics-based zoom and pan interactions.
Animation Orchestration
Choreograph complex multi-step animations with precise timing, dependencies, and staggering for creating memorable interface moments that feel intentional.
Physics Constraints
Define precise physical relationships between elements using distance, spring, or hinge constraints for complex, realistic interactions.
Chart Physics Interaction
Enable intuitive, physics-based zoom and pan directly within charts for seamless data exploration using `useChartPhysicsInteraction`.
GlassDataGrid Component
Display and interact with complex datasets using a performant grid featuring physics-based sorting and drag-and-drop capabilities.
GlassStepper Component
Guide users through multi-step processes with elegantly animated transitions powered by physics.
Animated Focus Ring
Enhance accessibility and clarity with the `GlassFocusRing` component and `useGlassFocus` hook, providing clear, animated focus indication.
Enhanced Collision Data
Gain deeper insights into physical interactions with detailed collision event data, including impact force, point, and velocity.
Glass UI Animation System
Dynamic Motion, Intuitively Crafted
Galileo Physics Animation System
Bring interfaces to life with animations that feel natural and responsive. Use intuitive hooks for common effects, or dive deep with direct access to the powerful physics engine for ultimate control.
Spring Physics Demo
Fluid spring dynamics for intuitive movement.
Interactive Physics
Apply realistic physics to UI elements with spring dynamics, magnetic attraction, and realistic inertia.
Hooks: usePhysicsInteraction, useMagneticElement
Gesture & Movement
Create natural movement with drag physics, Z-space depth effects, orchestrated multi-step animations, ambient tilt, and physics-based layouts.
Hooks: useGesturePhysics, useZSpaceAnimation, useAnimationSequence, useAmbientTilt, usePhysicsLayout
Direct Engine Access
For advanced users, gain granular control over the entire physics world, including constraints and enhanced collision data, for custom simulations.
Hooks: useGalileoPhysicsEngine, usePhysicsConstraint
Performance & Accessibility
Animation quality adapts to device capabilities and respects user motion preferences.
Hooks: useQualityTier, useDeviceCapabilities, useReducedMotion
Glass UI Theme System
Advanced Theming Architecture
Intelligent Theme System
A sophisticated multi-context architecture designed for maximum flexibility and performance. Adapt your interface to any brand, style, or user preference with elegant transitions.
Select Theme Variant
Choose a theme to see components adapt automatically via the integrated theme context.
Theme System Features (v1.0.22+):
- Multi-context architecture
- Physics-enhanced UI elements
- Theme-aware components (FocusRing)
- Animated theme transitions
Component Demo nebula Theme
Themed Card
This card adapts to the 'nebula' theme.
Focus Active: No | Ring Variant: primary
GlassStepper
Select Item
Configure
Confirm
GlassDataGrid
Component | Themed? |
---|---|
Card | Yes |
Button | Yes |
Stepper | Yes |
DataGrid | Yes |
FocusRing | Yes |
Glass UI Chart Components
Physics-Powered Data Visualization
Glass Charts & Data Visualization
Immersive, interactive data visualizations with spring physics animations and glass morphism effects
Dynamic Data Visualizations with Physics
Our DataChart component transforms data into beautiful, interactive visualizations. Leverage its modular architecture, adaptive rendering tiers, and physics-based animations.
- Spring physics animations with customizable parameters
- Multiple chart types: line, bar, area, pie and KPI displays
- Interactive glass tooltips with contextual information
- Adaptive performance with device capability detection
- Accessible animations that respect reduced motion preferences
- Modular architecture for flexible composition
- Physics-Based Zoom/Pan via
interaction.zoomPanEnabled
prop
Monthly Revenue
Interactive mode is enabled. Click on data points, try zooming (scroll wheel), and panning (drag).
Customize Chart
// Physics-based zoom and pan requires the useChartPhysicsInteraction hook import { useRef } from 'react'; import { DataChart, useChartPhysicsInteraction } from '@veerone/galileo-glass-ui'; function ChartWithPhysicsZoomPan() { // Create container ref for the physics interaction const chartContainerRef = useRef<HTMLDivElement>(null); // Initialize physics interaction with stiffness based on your preset const physicsInteraction = useChartPhysicsInteraction({ targetRef: chartContainerRef, stiffness: 120, // Adjust based on preset dampingRatio: 0.7, // Adjust based on preset reducedMotion: false // Use useReducedMotion() hook in real usage }); return ( <div ref={chartContainerRef} style={{ height: '400px' }}> <DataChart variant="line" datasets={datasets} animation={{ physicsEnabled: true, duration: 800 }} glassVariant="clear" blurStrength="standard" // Connect the physics plugin and mode chartPlugins={[physicsInteraction.plugin]} interaction={{ showTooltips: true, zoomPanMode: physicsInteraction.zoomPanMode }} /> </div> );}
Using Galileo Physics Engine | Quality Tier: high | Reduced Motion: No
Charts adapt automatically to your device capabilities and preferences
Glass UI in Action
Bringing Designs to Life
Realize Your Vision
Discover how Galileo Glass UI empowers developers to build stunning, intuitive, and performant applications across various domains.
Medical Patient Dashboard
Visualize patient vitals with fluid, interactive charts (`DataChart`), track treatment timelines (`GlassTimeline` - fixed), and manage records seamlessly. Physics enhances focus and interaction clarity.
Creative Portfolio Showcase
Craft stunning, dynamic project galleries using physics-driven layouts (`usePhysicsLayout`), subtle ambient tilt (`useAmbientTilt`), and engaging interactions via `GlassDataGrid` or `GlassMasonry`.
Financial Investment Platform
Deliver insightful performance data with interactive `DataChart` (featuring physics zoom/pan via `useChartPhysicsInteraction`) and responsive data tables (`GlassDataGrid` with drag/sort physics).
Smart Home Control System
Build intuitive controls with satisfying physics feedback (`usePhysicsInteraction`) and guide users through setups with animated `GlassStepper`. Visualize energy usage via `DataChart`.
Installing Galileo Glass UI
Installation
Get Started in Minutes
Follow these simple steps to integrate Galileo Glass UI into your project.
Step 1: Install Package
Install via npm
npm install @veerone/galileo-glass-ui styled-components
(`react`, `react-dom`, `styled-components` are required peer dependencies)
(Dependencies like `react-spring`, `framer-motion`, `popmotion` are internal and not required for installation.)
Optional Dependencies
Install only if using specific components:
- `chart.js`, `react-chartjs-2`: Required for `DataChart`.
- `date-fns`: Required for date/time pickers (e.g., `GlassDateRangePicker`). Needs `GlassLocalizationProvider` wrapper.
Import & Use Example
Import components and hooks as needed:
// Import components individually for better tree-shaking:
import { GlassButton } from '@veerone/galileo-glass-ui/components/Button';
// Or import hooks from the hooks entry point:
import { usePhysicsInteraction } from '@veerone/galileo-glass-ui/hooks';
import styled from 'styled-components';
// Required for 3D tilt effects
const Container = styled.div`perspective: 1000px;`;
function PhysicsButtonExample() {
const { ref, style } = usePhysicsInteraction({
animationConfig: 'gentle',
affectsTilt: true // Enable tilt
});
return (
<Container>
<GlassButton ref={ref} style={style}>
Physics Button
</GlassButton>
</Container>
);
}
Compatibility & Performance
React 19 Ready
Designed for compatibility with React 19 features. (Verify against official release notes if needed).
Bundle Size
Core library ~586KB, but highly tree-shakeable. Use specific imports for best results.
(See optimization docs for details)
Optimization: Tree Shaking
Use specific imports (e.g., `...@veerone/galileo-glass-ui/components/Button`) to minimize bundle size.
Troubleshooting Tips
- Ensure peer dependency `styled-components` is installed.
- For 3D tilt effects (`usePhysicsInteraction`), ensure the parent element has a `perspective` CSS property.
- Check `bugreports.md` in the project for known issues or temporary workarounds.
- If experiencing issues, try isolating the component or hook in a minimal test case.
Additional Resources
Documentation
Comprehensive guides and API references.
GitHub Repository
Explore the source code, report issues, or contribute.
Community Support
Join discussions and get help.
Browser Compatibility
Galileo Glass UI Documentation
Crafted With Care
Documentation That Inspires
Comprehensive guides that elevate your development experience from ordinary to extraordinary.
Framework Guide
Core concepts, architecture, and design principles.
Theme System
Customize colors, spacing, and component variants.
Project Structure
Understand the overall package architecture.
Installation Guide
Get started with setting up the library.
Animation System
Overview of the physics-based animation engine.
Physics Interaction Hook
Integrate physics with user interactions.
Animation Orchestration
Coordinate complex, timed animation sequences.
Physics Engine API
Direct access for custom physics simulations.
Advanced Components
Guides for complex components like DataGrid.
Glass Charts
Build adaptive, interactive data visualizations.
Specialized Surfaces
Explore advanced glass surfaces like WidgetGlass.
Timeline Component
Display sequential events interactively.
Performance Optimization
Optimize bundle size, rendering, and animations.
Accessibility Guide
Focus management and reduced motion support.
Component Patterns
Best practices for building components.
Coding Guidelines
Code style, standards, and conventions.
Every detail meticulously considered. Our documentation doesn't just explain—it inspires. Discover the possibilities of what you can create with Galileo Glass UI.
View All Documentation