Effective date: 2025-10-21
Version: 1.0
Business name: OMNI FX Studio (operating as “OMNI-FX”)
Website: https://omnifx.studio
Contact: hello@omnifx.studio
The documentation provided below is intended solely for educational purposes and to provide deep technical insight into the architecture of the OMNI-FX Motion Icon System. This document should not be taken as official guidance or professional advice tailored to your specific project. The buyer is solely responsible for ensuring the product meets their requirements and is compatible with their technology stack. We cannot provide comprehensive official learning resources as we are a motion studio, not a coding or development authority. We may make mistakes in coding and Development guidance. For proper, detailed understanding of the Rive ecosystem, developers should refer to the Rive Official Documentation.
0. Quick start (TL;DR)
Put the .riv asset in your project assets.
Load the Rive file with the Rive runtime for your platform.
Set number inputs (e.g.
IconIndex,ColorStyle,BackgroundStyle) and fireClickTriggerto commit icon changes.Use
Hover/HoverStylefor desktop hover behavior; disable hover for touch devices.
see Performance & legal note below.
1. Overview
1.0 Core Problem OMNI-FX Solved for Developers
OMNI-FX is a professional-grade tool designed to accelerate your workflow and eliminate the compromise between complex design visions and production code. It addresses the high cognitive load caused by jarring, static icon state switches by offering seamless, fluid morphing. Our system saves developers hundreds of hours that would otherwise be spent building sophisticated motion from scratch.
This system is not a library of simple, looping animations; it is a true state machine engine. Our goal is to empower ambitious creators to build the fluid, dynamic, and unforgettable user experiences they've always envisioned.
1.1 What is OMNI-FX
OMNI-FX is a next-generation motion icon system designed in Rive to bring dynamic feedback and expressiveness to UI interactions.
The brand name OMNI-FX is rooted in the philosophy that interfaces should feel less like code and more like life:
OMNI stands for One Matter Neural Interaction, representing the convergence of design logic (Matter), responsiveness (Neural), and user flow (Interaction) into one cohesive system.
FX stands for Fluid Experience, reflecting our commitment to creating adaptive and reactive user interfaces.
We designed the interaction logic with developers in mind. We utilize Number inputs for core state control (like IconIndex, ColorStyle, etc.), specifically utilizing the 0 and 1 states because developers frequently interpret these numbers as defining the false or true state (e.g., DisabledState=1 for true/on, DisabledState=0 for false/off), which they use daily. The entire system is designed around the concept of One Matter, aiming to make every icon feel responsive, moving, and alive, just like a living organism.
1.2 Why number inputs?
Developers work with booleans and numeric states all day. OMNI-FX exposes intuitive number/boolean/trigger inputs so you can drive icons with code (numbers for IconIndex, ColorStyle, BackgroundStyle, booleans/triggers for hover & click). This reduces glue code and avoids per-icon animation wiring.
1.3 Core Philosophy
The OMNI-FX motion system is built on a design mindset centred on:
Fluid Motion: Providing a continuous visual path during state changes.
Precision Timing: Curated timing to ensure animations are neither too slow nor too fast, staying within the optimal range (like the 400ms transition time), which is informed by reaction time studies.
Emotional Interactivity: Transforming functional design into moments of user delight.
Adaptive Responses: Ensuring the icons react intelligently to different environments (e.g., handling hover differently on touch devices).
1.4 Why Motion Icons Matter
OMNI-FX solves the gap where static icons lack communication power. Motion-driven icons communicate not just the immediate action, but the resulting state and energy. Using our motion icons helps products feel modern, professional, and distinct from generic solutions. This improved interaction quality is directly correlated with a better conversion experience.
1.5 How OMNI-FX Is Built
The system is engineered on the powerful Rive state machine engine, ensuring smooth performance and cross-platform interaction.
Rive Foundation: We use Rive's vector art capabilities combined with complex state machines to control transitions and inputs.
Vector Feathering: Please note that no Vector Feathering is used in this pack (nor in the Starter, Core, Creator, or Studio packs).
2. File Architecture
2.1 Final Delivery Zip File Structure Overview
Each OMNI-FX digital package is delivered as a structured zip file containing the essential files and documentation:
[PackName].riv: The main Rive file for the chosen pack (e.g.,omnifx_core.riv).README.md: Introductory overview and quick start guide.LICENSE.md: The chosen license (Personal or Commercial).FEATURES.md: Details features, colors, hover effects, etc..NAMING.md: A simple file mapping numerical inputs to icon names, aiding developer recall.DOCS.md: This comprehensive documentation file.EULA.md: The End User License Agreement.REFUNDPOLICY_SUMMARY.md.RefundPolicy.md.About_OMNI-FX.md: Information about OMNI FX Studio and the brand philosophy.FEEDBACK.md: Guide and link to the feedback/review form.CUSTOMIZATIONS.md: Guide for requesting custom work or brand adaptation.
2.2 Inside Each Rive File
The Rive files share a consistent internal architecture, regardless of the pack variant:
Filename:
omnifx_<variant>.riv(starter,core,creator,studio)Artboard Name:
OMNI_MagicBoard.State Machine Name:
StateMachine.
The core interaction is driven by eight inputs:
Input Name | Type | Purpose | Pack Ranges | Default State |
| Number | Changes the icon displayed | Starter: 1–7; Core: 1–20; Creator: 1–30; Studio: 1–50. | 0 (Invisible/Zero State). |
| Number | Changes the primary color palette | Starter/Studio: 1–15; Core: 1–2 (Light/Dark); Creator: 1–5. | 0 (Invisible). |
| Number | Changes the bounding box background color | Starter: 0–10; Core: 0–2; Creator: 0–5; Studio: 0–10. | 0 (Invisible/No background). |
| Number | Selects the type of hover interaction | 0 (Disabled/False); 1 (Wake Effect); 2 (1–2% Scale); 3 (Looping Heartbeat). | 0 (No hover). |
| Number | Toggles the subtle gradient overlay | 0 (Off); 1 (On/True). | 0 (Off). |
| Number | Toggles the disabled, desaturated state | 0 (Off/Normal); 1 (On/True). | 0 (Off). |
| Boolean | Automatic listener for mouse over | Auto listener. | Off (False). |
| Trigger | Explicitly fires the state transition | Auto listener/Programmatic fire. | N/A (Momentary event). |
2.3 File Naming Convention
The file naming convention is consistent, lowercase, and uses underscores for clarity, which is beneficial for development workflows:
omnifx_starter.rivomnifx_core.rivomnifx_creator.rivomnifx_studio.riv
The variant (e.g., core, studio) clearly indicates which pack was purchased.
For in-depth feature breakdowns and features of pack, visit our Features Page at https://omnifx.studio/features
3. Core Logic & Interaction Flow
The OMNI-FX system is engineered to behave like One Matter (OMNI), ensuring that every transition is smooth, predictable, and functional.
3.1 The OMNI-FX State Model
The entire animation architecture is built around the Central Junction State, also known as the "Zero State".
Junction Hub: This state is where all Number inputs default to
0. Critically, this state is set to be invisible.Any-to-Any Morphing: This architecture is an intentional feature that allows for seamless, fluid morphing from any icon state to any other icon state without requiring thousands of rigid, individual transitions within the state machine.
Initial Load (Problem & Solution): Because the default state is the invisible Zero State (
IconIndex=0), the icon will be invisible when the Rive file first loads. This is designed intentionally to avoid a 'hatching' effect (flickering or sudden visibility) when the Rive file loads and adopts its initial State Machine inputs. To solve this, developers must set their desired default state (e.g.,IconIndex = 5) and then fire theClickTriggeronce to move the state machine out of the junction and into its first visible state.
3.2 Inputs & Triggers
The interaction flow relies on the interplay between Number inputs and the ClickTrigger:
Number Inputs (
IconIndex, etc.): Changing a Number input value (e.g., settingIconIndexfrom 2 to 3) only prepares the state change. The new path is selected, but the animation is not yet executed.The State Commit Trigger (
ClickTrigger): To execute the animation and make the change visible, the developer must fire theClickTrigger. This trigger commits all current input values and tells the state machine to animate from the central junction state to the new, visible state.Auto-Trigger Logic: The
ClickTriggeris configured to fire automatically upon every click on the animation. However, programmatic control is necessary for the initial setup (Zero State solution) or for complex sequenced interactions.
3.3 Hover vs Touch Design
The OMNI-FX system provides a device-aware hover system.
Desktop: The Boolean input
Hoverhas an auto listener, which automatically turns on when the user hovers over the file.Mobile/Touch: The concept of "hover" does not exist; a tap triggers the active animation once. To prevent misinterpretations (like hover animations getting stuck in a loop on touch devices), developers should detect the user's device and set the
HoverStyleinput accordingly.Set
HoverStyle = 0to completely disable hover animations for touch devices.
3.4 Built-In Safety Resets
The icons employ non-looping logic and automatic resets.
Predictability: This design choice is intentional to keep the icons predictable and performant within the UI.
Self-Correction: If the user clicks the icon but the
IconIndexinput remains the same, the icon will morph through the zero state and return to its current visible state, ensuring continuity without triggering an unintended change.
4. Implementation Guide
This section outlines the basic setup for integrating OMNI-FX icons using the Rive runtime libraries, which are open-source and available on GitHub.
4.1 Getting Started
Integrating OMNI-FX requires incorporating the .riv file into your project assets and initializing the Rive runtime.
Include the
.rivfile: The file must be included in your project assets. For web applications, you can load the file via a Hosted URL, as a static asset bundled in your project, or by fetching the raw bytes into anArrayBuffer.Initialize the Runtime: Rive runtimes must be initialized before use (e.g., in Flutter, calling
await RiveNative.init()is encouraged).Basic Setup: When instantiating the Rive object, you must specify the file source, the Artboard (
OMNI_MagicBoard), and the State Machine (StateMachine).
We cannot provide comprehensive official learning resources as we are a motion studio, not a coding or development authority. We may make mistakes in coding and Development guidance. For proper, detailed understanding of the Rive ecosystem, developers should refer to the Rive Official Documentation.
4.2 Implementation Examples
The core implementation logic involves using framework-specific Rive hooks (React) or controllers (Flutter) to gain programmatic access to the State Machine inputs.
React Example (using @rive-app/react-canvas)
The recommended approach involves using the useRive hook and the useStateMachineInput hook to manage the state machine inputs. The use of a useRef flag is critical to ensure the Zero State Initialization runs only once on component mount.
// --- Imports and Configuration ---
import { useRive, useStateMachineInput } from '@rive-app/react-canvas';
import RiveFile from './assets/omnifx_pro.riv'; // Import your file
// --- Device Detection Utility (Recommended for Hover Control) ---
const isTouchDevice = () => {
if (typeof window === 'undefined') return false;
return 'ontouchstart' in window || navigator.maxTouchPoints > 0;
};
// --- Inside your component ---
const { rive, RiveComponent } = useRive({
src: RiveFile,
artboard: 'OMNI_MagicBoard',
stateMachines: 'StateMachine',
autoplay: true,
});
// Get hooks for the essential inputs
const iconIndexInput = useStateMachineInput(rive, 'StateMachine', 'IconIndex');
const hoverStyleInput = useStateMachineInput(rive, 'StateMachine', 'HoverStyle');
const clickTriggerInput = useStateMachineInput(rive, 'StateMachine', 'ClickTrigger');
const isInitialMount = useRef(true);
const isMobileDevice = useRef(isTouchDevice());
// This useEffect handles the critical initialization
useEffect(() => {
if (rive && isInitialMount.current) {
// 1. Set your desired default icon
iconIndexInput.value = 2; // e.g., the 'Menu' icon
// 2. Set the correct hover behavior for the device
hoverStyleInput.value = isMobileDevice.current ? 0 : 1; // 0 for mobile, 1 for desktop
// 3. Fire the trigger to apply the initial state (Critical for Zero State Solution)
clickTriggerInput.fire();
isInitialMount.current = false; // Prevent this from running again
}
}, [rive, iconIndexInput, hoverStyleInput, clickTriggerInput, rive]);
// ... component logic continues ..
Flutter Example
Flutter implementation often utilizes the RiveWidgetBuilder which handles resource loading and management automatically. The FileLoader is used to load the asset, and the resulting controller provides access to the State Machine inputs via the RiveWidgetController.
// Example of using RiveWidgetBuilder for resource management and loading
late final fileLoader = FileLoader.fromAsset(
"assets/omnifx_core.riv",
riveFactory: Factory.rive // Recommended Rive Renderer
);
// ... dispose fileLoader in the widget's dispose method ...
// RiveWidgetBuilder handles loading, error states, and building the RiveWidget
return RiveWidgetBuilder(
fileLoader: fileLoader,
builder: (context, state) => switch (state) {
RiveLoaded() => RiveWidget(
controller: state.controller, // Access the controller here
fit: Fit.cover,
),
// ... handle RiveLoading and RiveFailed states ...
},
);
// In Flutter, you access inputs via the StateMachineController from the RiveWidgetController.
4.3 Handling State Inputs
Once initialized, controlling the icon is achieved by modifying the Number input and triggering the change.
To change an icon state:
Set the
IconIndexvalue to the desired number (e.g., 2 for 'Menu', 3 for 'Close').Call the
ClickTrigger.fire()method (in web runtimes) to commit and execute the transition.
To control non-icon states (Color, Background, Gradient, Disable):
All other input changes, other than IconIndex, will adapt and change automatically within 400ms after the State Machine input changes.
4.4 Responsive & Performance Tips
Retina Display Handling: To prevent blurry output on high-DPI (Retina) screens, it is highly recommended to call
resizeDrawingSurfaceToCanvas()on the Rive instance when it loads, typically within theonLoadcallback. This adjusts the canvas drawing surface based on the device pixel ratio.Scaling and Layout: Use the Rive
Layoutparameter (which includesFitandAlignment) when instantiating the Rive object, or set it dynamically usingriveInstance.layout = new Layout({...}).Performance: The Studio pack file size is approximately 1.29 MB. Rive animations are built on vector blueprints, not heavy raster images or videos, making them highly efficient for running many instances simultaneously (instancing) without significant CPU/GPU strain.
Note:
Demo files visible on the OMNI-FX website and socials are simulation assets — not identical to your purchased .riv pack.
They are intentionally simplified for display security and may behave slightly differently (for example, missing the 400ms interactive threshold).
This variation is by design to prevent piracy and does not affect licensed file performance.
5. Customization & Editing
5.1 Editable Elements
The OMNI-FX system provides several programmatic points of customization via the State Machine inputs:
Colors: Change the icon colour palette via the
ColorStylenumber input (range 1 to 15, depending on the pack).Backgrounds: Change the bounding box background via the
BackgroundStylenumber input (range 1 to 10, depending on the pack).Gradient Fill: Toggle the subtle gradient effect using the
GradientFillinput (0 or 1).Animation Timing and Easing: While the overall 400ms transition time is fixed by design, developers can still influence the precise execution of the animation within their application logic.
Since the icons are delivered as .riv files intended only for runtime use, there are no user-editable elements outside of the inputs and parameters provided. If the user requires special customization—such as swapping the default palette with custom brand colours, animating their own icons in the OMNI-FX style, or requesting custom motion interaction—they should contact OMNI FX Studio for creative services.
5.2 Best Practices
To maintain the high quality of the OMNI-FX system and its intended motion identity, we recommend maintaining motion rhythm, timing consistency, and interactivity quality across your implementation. Customization of colors and backgrounds should align with your existing design system to ensure coherence.
6. Common Scenarios
6.1 Zero State Not Visible
Scenario: The icon does not appear when the component first loads. Intentional Design Choice: This is not a bug. The State Machine is engineered around a central, invisible "Zero State" where all initial inputs are 0. This architecture is necessary for seamless, fluid morphing between any two icons. Solution: The developer must programmatically set the default IconIndex (e.g., IconIndex = 5) and then immediately fire the ClickTrigger once during component initialization.
6.2 Animation Doesn’t Trigger
Scenario: The icon index is changed, but the animation does not execute. Troubleshooting:
Ensure the correct
stateMachinesname (StateMachine) was provided during Rive instance initialization.Verify that the
ClickTrigger.fire()method was explicitly called after setting the newIconIndexvalue. Changing the index only prepares the state; the trigger commits the change.Confirm that the Rive runtime dependency is correctly installed and compatible with your platform.
6.3 Animation Keeps Looping
Scenario: An icon animation plays repeatedly. Intentional Design Choice: The core logic employs automatic resets and non-looping logic by design. If an animation appears to loop unintendedly, ensure you are not accidentally setting up an external mechanism (like a timer or continuous re-render) that repeatedly fires the ClickTrigger or resets the state machine.
6.4 Icon Flickers or Freezes
Scenario: The icon appears blurry, flickers, or the animation freezes. Troubleshooting:
Blurriness (Retina): If the graphic is blurry, the canvas width/height attributes may not account for the device pixel ratio. Call the
resizeDrawingSurfaceToCanvas()function on load and on window resize.Freezing: Check the browser console for CORS errors if loading the
.rivfile from a CDN, and ensure necessary internet permissions are set (especially in Android/Apple if loading via URL).Hitching: Ensure the host component or view hierarchy provides sufficient dimensions for the
<canvas>element.
6.5 How to create many icon instances with the same .riv file
Scenario: You need 10 or 20 distinct icons displayed on one page using the same .riv file, ensuring performance is maintained. Solution (Instancing and Caching): Rive is highly optimized for this. You should reuse the same core .riv file object across multiple Rive instances to improve performance and optimize memory usage. This is known as caching the Rive file.
Web/React: Load the file once (e.g., via ArrayBuffer or a cached fetch) and pass the resulting
RiveFileobject to theriveFileparameter when instantiating subsequent Rive components.Flutter: Reuse the same
FileLoaderobject across multipleRiveWidgetBuilderinstances. The underlyingFilewill only be loaded and decoded once.
7. Troubleshooting & Intentional Design Choices
7.1 Known Limitations (Framed Design)
Certain architectural decisions within OMNI-FX, while potentially presenting limitations in edge cases, are intentional choices rooted in the "One Matter" design philosophy and commitment to performance.
Limitation | Intentional Design Choice & Philosophy |
Fixed 400ms Transition Time | The transition time is highly curated by our designers to be ideal for showcasing the beauty of the morphing animation. This time frame is deemed sufficient to show the matter fully morphing, placing the animation within a well-regarded range (200ms to 400ms) for interaction feedback. |
No Persistent Hover State | This design choice ensures stability and performance across various devices and runtimes, especially preventing issues on mobile devices where tap input can interrupt complex hover loops. |
Fixed Easing Curves | The easing curves are fixed to guarantee the OMNI-FX motion identity. This consistency ensures the liquid, responsive feel of the "One Matter" philosophy is maintained in every interaction. |
Cannot Trigger State Changes Faster than 400ms | If a user clicks again (firing the |
7.2 Developer Tips
Preload Assets: Always preload your assets, especially when integrating via network or CDN. If loading from the internet, cache the file in memory to avoid repeated downloads and decoding.
Controlled Triggers: Prefer using controlled programmatic triggers (
.fire()) over relying purely on Rive's automatic listeners for complex or stateful UI logic.Lazy Loading: On icon-heavy pages (e.g., large dashboards or feature lists), prefer lazy loading the icons that are off-screen to minimize initial load time and resource allocation.
Version Control: When checking in
.rivfiles with Git, add a.gitattributesfile and mark.rivfiles asbinaryto prevent Git from corrupting the file by changing line endings.
7.3 Common Misconceptions
It is crucial to understand that OMNI-FX icons are not static SVGs. They are live motion systems built on the Rive State Machine, requiring full Rive runtime support in the application environment (e.g., dedicated Rive dependencies for React, Flutter, Android, etc.). This means that simple image embedding or standard SVG components will not work.
8. Integrating into Real Products
8.1 Use in Websites & Apps
OMNI-FX is designed for embedding in modern UI frameworks. You should select the appropriate Rive runtime package for your platform:
Web (Plain JS/HTML): Use the
@rive-app/canvaspackage for easy integration and compatibility.React: Use the recommended
@rive-app/react-canvaspackage.Mobile (Native/Hybrid): Use the Flutter, Android, or Apple Rive runtimes. In Flutter, using the Rive Renderer (
Factory.rive) is often recommended for complex graphics and performance optimization, especially when paired withRivePanelfor multiple instances.
8.2 Animation Sync with UI Events
To map OMNI-FX motion to UI events:
Click/Tap: Map button clicks or tap gestures to a function that performs the two-step state change: set
IconIndex.valueand then callClickTrigger.fire().Hover: Use the framework's mouse enter/leave events to control the Rive instance manually, or rely on Rive's internal listeners combined with the
HoverStyleinput.Dynamic State: Use Rive's playback APIs (
play(),pause(),stop()) to manually control the animation when UI events like scrolling, loading, or user authentication change the context.
9. Advanced Notes (Optional)
9.1 Rive Runtime References
For in-depth details on core Rive functionality, consult the official documentation:
Topic | Rive Documentation Links |
Web (JS) Runtime | [Web (JS) - Rive] |
React Runtime | [React - Rive] |
Flutter Runtime | [Flutter - Rive] |
Android Runtime | [Android - Rive] |
Apple Runtime | [Apple - Rive] |
State Machine Playback | [State Machine Playback - Rive] |
Loading Assets & Caching | [Loading Assets - Rive] |
9.2 Nested FX & Compound Icons
The centralized State Machine architecture allows for compound effects. By combining numerical input changes across multiple fields (e.g., setting IconIndex, changing ColorStyle, and enabling GradientFill=1) before firing the ClickTrigger, developers can commit to a complex, multi-state visual identity in a single fluid transition.
9.3 Export Variants & Optimization
The OMNI-FX files are already highly optimized:
File Size: The largest pack, the Studio Pack (50 icons), is approximately 1.29 MB.
Frame Rate: Icons are designed for a smooth 60 FPS experience.
Rendering: The reliance on the Rive Renderer (especially when using
Factory.rivein Flutter or WebGL packages in React) leverages GPU acceleration for lightweight, performant rendering.
10. Credits & Licensing
10.1 OMNI-FX Copyright and Attributions
All motion logic, animation, and Rive state designs © OMNI FX Studio.
Our Design Philosophy & Attributions
At the heart of OMNI is a simple idea: to bring digital interfaces to life. Every animation, every transition, and every interaction has been meticulously crafted to create a delightful and intuitive user experience.
Foundation Inspiration:
To ensure OMNI-FX icons are instantly recognizable and highly usable, we began with the visual structure of Heroicons, an open-source icon library by Tailwind Labs.
We then redesigned, optimized, and animated these base shapes through our proprietary OMNI-FX motion system — creating a unique, dynamic design experience.
OMNI-FX is a fully original product built upon legally permitted open-source foundations.
Our animations, morph systems, and motion behaviors are entirely our own.
Acknowledgment:
We are grateful to the creators of Heroicons for their contribution to the design community.
The following MIT License text applies only to the original static Heroicons that inspired the OMNI-FX icon forms — not to the OMNI-FX animations, system, or product itself.
Heroicons License (for attribution only)
MIT License
Copyright (c) Tailwind Labs, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
(Heroicons is a project by Tailwind Labs; OMNI-FX is not affiliated with or endorsed by Tailwind Labs.)
Platform Logos Disclaimer
The platform logos displayed on the OMNI-FX website (React, Web (JS), Android, Flutter, and Apple (iOS)) are used solely for informational and illustrative purposes — to visually indicate technology compatibility with Rive SDKs.
These logos are not included in any OMNI-FX product files, nor used for any commercial redistribution or branding.
All trademarks, service marks, and logos remain the property of their respective owners.
The icon assets used for this section are sourced under the MIT License as shown below.
Devicon License (for attribution only)
The MIT License (MIT)
Copyright (c) 2015 konpa
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
11. Support & Resources
11.1 Official Support and Customization for Your Brand
OMNI FX Studio is here as your motion design teammate. We offer specialized support for technical issues and professional services for custom brand alignment.
Contact for Support or Licensing Queries: 📩 hello@omnifx.studio
Contact for Customization Requests: For custom colors, unique icon animation (in the OMNI-FX style), or full brand motion identity development, please email us with the subject line: "Customization Request".
11.2 Learning Links
Since implementation requires technical knowledge, we encourage deep exploration of the official Rive documentation:
Rive Official Documentation Home: Runtime Fundamentals, Getting Started.
Rive Community & Tutorials: For code samples and advanced learning.
11.3 Updates & Changelog
This space is reserved for future version notes and feature additions. Updates may be provided free or at a discounted price at our discretion. Other products, such as "OMNI Buttons" or "Hero Animations," are separate purchases.
12. Legal & Accuracy Disclaimer
12.1 Design Intent & Technical Boundaries
OMNI-FX follows a deliberate balance between artistic control and developer flexibility.
Not all parameters are open-ended — some are intentionally fixed to preserve the
brand’s visual rhythm, responsiveness, and “One Matter” motion identity.
Developers should not interpret fixed durations, easing curves, or locked inputs as bugs,
but as design guardrails ensuring a consistent, fluid experience across all platforms.
12.2 Developer Responsibility & Recommended Knowledge
OMNI-FX assumes a working understanding of Rive runtime concepts and the host framework
(React, Flutter, etc.). The product is designed for professional developers and
advanced designers familiar with state machines, event triggers, and animation playback APIs.
We do not provide full-code training, debugging, or implementation support beyond the
scope of our integration notes. For best results, consult the official Rive documentation
for detailed runtime usage and platform-specific nuances.
12.3 Support Policy Summary
Support is provided strictly for issues related to:
Corrupted or inaccessible .riv files after purchase
Incorrect animation behavior inconsistent with this documentation
Clarification of input names and usage within Rive
Support does not cover:
Implementation bugs in your project code
Framework or library conflicts
Learning assistance for Rive or programming languages
All support is handled via email at hello@omnifx.studio.
We’re here as your motion design teammate — ready to make your brand move. 🚀
© 2025 OMNI FX Studio. All rights reserved.
hello@omnifx.studio | https://omnifx.studio.
Built by OMNI FX Studio — Responsive. Moving. Alive..