• First, relevant data is retrieved from a data source

• Then the LLM uses this information to generate an answer to a query

Why does RAG exist?

A Large Language Model only knows the information with which it was trained. This means that data that was published after the training time or was not included in the original training data - such as internal company documents - is unknown to the model.

RAG was developed precisely for such cases in order to supplement an LLM with up-to-date information and thus give it access to areas of knowledge for which it was not directly trained.

What is RAG good for?

• It can access current or specialized data, e.g. company knowledge, documents, websites, etc.

• It gives better and more accurate answers because it gets the information from real sources.

• It is more flexible: you don't have to retrain the model when you have new data - you just have to enter it into the search system.

Example with a slightly technical background

If we want to provide a language model (LLM) with information from a book that it does not know, it would be inefficient to simply insert the entire book text - that would be too long and would exceed the token limit.

Instead, a process is used in which only the most relevant parts of the book are selected. To do this, the book text is first broken down into small sections and each of these sections is converted into a number vector (embedding) using an embedding model.

When a user asks a question, this question is also converted into a vector. This vector is then compared with the vectors of the book sections - the more similar they are, the more likely they are to match in terms of content.

The best matching sections are then passed back to the language model in text form as context. This allows the LLM to answer the question as if it had access to the book - without the book actually being included in the model training.

I hope I was able to explain RAG to you in a simple way. If you have any questions, please contact me.

Best regards

Thomas from the Quantyverse

Jetzt abonnieren

P.S.: Visit my website Quantyverse.ai for products, bonus content, blog posts and more

In my last devlog, I introduced you to my chat UI with NiceGUI. Today I would like to show you a new project: QV-RAG, a simple RAG engine for semantic search and document management.

Why your own RAG engine?

Up to now, I have used more complex frameworks for semantic searches. Although these were powerful and worked very well, they were also overloaded with functions that I didn't need. So I decided to develop my own, lean RAG engine that does exactly what I need - no more and no less. Also with the background of really understanding what I was doing.

The structure

The engine consists of three main components:

1. a text splitter for intelligent document splitting

2. a storage system based on ChromaDB

3. a simple API for document management and queries

The code has a modular structure and is easy to extend. This makes the engine not only easy to use, but also easy to maintain and customize.

The implementation

The main class `RAGEngine` is the entry point for all operations. It connects the various components and provides a clear API:

```python

engine = RAGEngine(

    collection_name="my_docs",

    chunk_size=1000,

    chunk_overlap=200

)

```

The engine supports various document types:

• Text files

• Markdown

• HTML

• JSON

• PDF (works but still needs to be improved)

Add documents

Adding documents is very simple. You can either add individual texts or entire files:

```python

# Add individual texts with metadata

engine.add_texts(

    texts=["Python is a popular programming language."],

    metadatas=[{"source": "manual", "category": "docs"}]

)

# Add a file

engine.add_file("document.md", metadata={"source": "file"})

```

The engine takes care of this automatically:

• Recognizing the file type

• Splitting into meaningful chunks

• Distributing the metadata to the chunks

• Storage in the database

The search function

The semantic search is simple and effective:

```python

results = engine.query(

    "What is Python?",

    where={"category": "docs"},

    top_k=3

)

```

The engine not only provides the relevant text passages, but also metadata and similarity values. This makes it easy to filter and evaluate the results.

Features

What QV-RAG does:

• Intelligent text splitting with metadata preservation

• Simple API for fast integration

• Support for different document types

• Flexible metadata management

• Persistent storage with ChromaDB

Conclusion

QV-RAG is an example of how to build a good working RAG engine with relatively little code. The engine may not be the ultimate RAG engine, but it is still a useful tool for semantic search and document management.

You can find the complete code in the GitHub repository:

[QV-RAG]

There you will also find examples and documentation that show you how to use the engine in your projects.

See you next time,

Thomas from the Quantyverse

Jetzt abonnieren

P.S.: Visit my website Quantyverse.ai for products, bonus content, blog posts and more

Why NiceGUI?

So far, I have mostly used TypeScript frameworks for user interfaces, such as React. This time, however, I was looking for a Python solution and found NiceGUI. I was a bit skeptical at first, but as I got to know the Python framework, my enthusiasm grew. It is based on Vue and Quasar. It finds a good middle ground between magic (which makes development easier) and fundamental building blocks to build real custom things. So, here's how the simple UI is structured.

The structure

The chat application consists of three main parts:

1. a header with model selection and settings

2. a chat area that displays the conversation

3. a footer with input field and send button

The code is divided into small, focused components. This makes the application easy to maintain and expand.

The implementation

The main application file is quite simple. It sets up the basic structure and connects all components:

```python

@ui.page('/')

def main():

    # initialize manager

    model_manager = ModelManager()

    chat_manager = ChatManager(model_manager)

    dialog_manager = DialogManager(model_manager, chat_manager)

    # Create header

    create_header(dialog_manager, model_manager)

    # Main area

    with ui.column().classes(f'w-full max-w-{MAX_WIDTH} {MARGIN_X} {MARGIN_Y}'):

        chat_manager.chat_messages()

        ui.timer(UI_REFRESH_INTERVAL, chat_manager.chat_messages.refresh)

    # Create footer

    create_footer(chat_manager)

```

The chat interface automatically refreshes every 0.1 seconds to display new messages. This ensures a smooth experience when receiving replies from the LLM.

The chat experience

The chat interface is designed to be simple and intuitive:

• Messages appear in a clean, modern layout

• The input field is always visible at the bottom

• Messages can be sent by clicking on the Send button or by pressing Enter

• The conversation history is saved automatically

The current implementation provides a solid foundation that can be expanded as required.

You can find the complete code in the GitHub repository:

[QV Ollama Simple UI]

There you will also find the other code modules that you can view and how to start the UI.

See you next time,

Thomas from the Quantyverse

Jetzt abonnieren

P.S.: Visit my website Quantyverse.ai for products, bonus content, blog posts and more

But what exactly are Large Language Models? Put simply, you can think of them as text-based assistants that can recognize patterns and generate suitable answers to questions based on large amounts of training data. For example, if you ask for a recipe with coconut milk, ginger and vegetables, the LLM will probably suggest a curry recipe - simply because it has learned that these ingredients often go together. But how does an LLM actually "learn" and where does its extensive knowledge come from?

How does a Large Language Model learn?

A Large Language Model (LLM) is essentially based on a neural network with a special transformer architecture - but more on this in another article. These networks can be trained to develop certain skills. In the case of LLMs, this means that they are fed a huge amount of text - we are talking about data volumes in the range of several terabytes, which include large parts of the Internet such as Wikipedia, books, news articles and many other texts.

During training, the model learns to recognize patterns and correlations in texts. As a result, it can predict with a high degree of probability which word might follow next. This creates a kind of rough "world model" - albeit limited.

For example, if the model reads: 'Today the... is shining', it calculates from previously learned patterns that the next word is probably 'sun' and not 'banana'. This is exactly how meaningful texts are created.

The model doesn't really understand things in a human sense. It doesn't really understand concepts like gravity, it just reproduces relationships from the training data. It has no real understanding of physics. It generates and combines words very quickly on the basis of probabilities.

Nevertheless, large language models are real all-rounders and can support us in many areas of everyday life and work. Imagine you need help writing a blog post, want to quickly summarize a long article or explain complicated topics in an understandable way - this is exactly where these AI systems come into play. They can also be a great help when programming by generating code snippets or assisting with troubleshooting. All these applications have one thing in common: they make our work easier and faster. However, you should always check the answer for correctness if you as a user have the feeling that something might not be correct.

LLMs come in different sizes. The best models such as GPT4o, GPT-o1 or Claude 3.7-Sonnet are very large and require large amounts of computing capacity, which is why they have to be operated in data centers. This also means that we do not have complete control over how our data is processed or stored.

Meanwhile, there are also small but powerful Large Language Models such as Gemma 2 and Gemma 3 from Google. These smaller variants, often referred to as Small Language Models (SLMs), are compact enough to be run locally. In other words, on a home computer or even on a smartphone.

My focus in the Quantyverse is on these local application possibilities with SLMs - I develop applications that run directly on my own hardware. They can't compete with the big models from OpenAI or Anthropic. But even the smallest SLMs are getting more and more impressive and are already very helpful for many tasks. If you're curious about what I'm developing, feel free to drop by or create an account to stay up to date.

I hope this blog article has given you a good insight and that I have been able to introduce you to Large Language Models without getting too technical.

See you next time and best regards

Thomas from the Quantyverse

Jetzt abonnieren

P.S.: Visit my website Quantyverse.ai for products, bonus content, blog posts and more

In recent years, large language models such as GPT4o, Claude-3.7-Sonnet or Deepseek-V3 have changed the way we interact with technology. We can now talk directly to these systems in apps such as ChatGPT and receive direct responses to our queries. The models seem to remember previous conversations and provide contextual feedback.

But how exactly does this actually work? Technically speaking, LLMs only generate responses to individual queries and do not have an integrated memory in their neural network. It's almost as if they have a kind of memory, although technically speaking they don't have a memory of their own.

If you have a longer conversation with a Large Language Model (LLM), the so-called context window comes into play. What happens is that the LLM not only receives the latest requests and responses, but also all previous messages. The longer the conversation lasts, the more extensive the text that is fed into the language model becomes.

However, LLMs have a limitation: they have a fixed context window that defines how much text they can store and process at a time. If a conversation becomes too extensive, the neural network may no longer remember all previous questions and answers. The result is that it loses the context of the conversation and thus provides less precise or even poor answers.

But Large language models are developing rapidly and their context windows are becoming ever more extensive. Some models, such as Gemini 1.5 or Qwen-2.5-Turbo, are already reaching the millions, and this trend is continuing.

The scale of this development means that in the near future entire books can be easily integrated into a Large Language Model (LLM). This opens up ever better possibilities for information processing and knowledge integration.

The situation is different for smaller models, especially for local AI systems. Context windows still play a decisive role here. These models have a more compact design and therefore have significantly smaller context windows, which limits their ability to absorb and process information.

This has a direct impact on the applicability of such systems. Smaller models have to be cleverer with their limited memory space. They develop strategies to select and prioritize important information.

One example is Retrieval Augmented Generation (RAG), which makes it possible to pull specific knowledge from a database in response to a query and use it to feed the LLM without needing the entire document. But more on this in another blog post.

I hope I was able to give you an understanding of what the context window is and hope you continue to have fun with AI. Until next time.

Best regards

Thomas from the Quantyverse

Jetzt abonnieren

P.S.: Visit my website Quantyverse.ai for products, bonus content, blog posts and more

There are good reasons to document projects. For me personally, these are above all:

- A look back: how have I developed and what have I learned?

- To share inspiration: Others can benefit from my journey

- Self-reflection: Understanding my work better and questioning it critically

I am starting my devlog based on these considerations. I will record my development steps here - as a reminder for myself and perhaps also as motivation or inspiration for others.

Ollama as a backend

I rely on local AI because I am convinced that AI systems should run on private hardware. There are various solutions for running Large Language Models (LLMs) directly on your own computer. However, I am particularly fond of Ollama. I will therefore use Ollama as the LLM backend for my AI applications.

QV Ollama SDK

Ollama not only impresses with its simple use of Large Language Models (LLMs), but also with its efficiency. The Python API is user-friendly and straightforward. When I started building an AI chat application, I quickly realized that I needed a small solution to have conversations with a full conversation history. This means that the LLM not only receives the latest message, but the entire context of previous requests and responses. To simplify this process, I developed a small Python SDK that allows messages to be saved in chat histories. The LLM's response can either be streamed or output as a whole. Here is an example of a simple output.

```python

from qv_ollama_sdk import OllamaChatClient

# Create a client with a system message

client = OllamaChatClient(

    model_name="gemma2:2b",

    system_message="You are a helpful assistant."

)

# Simple chat - uses Ollama's default parameters

response = client.chat("What is the capital of France?")

print(response)

# Continue the conversation

response = client.chat("And what is its population?")

print(response)

# Set specific parameters only when you need them

client.temperature = 1.0 # Using property setter

client.max_tokens = 500 # Using property setter

client.set_parameters(num_ctx=2048) # For multiple parameters

# Get conversation history

history = client.get_history()

```

Or if you want to stream the answer of the LLM:

```python

from qv_ollama_sdk import OllamaChatClient

client = OllamaChatClient(model_name="gemma2:2b")

# Stream the response

for chunk in client.stream_chat("Explain quantum computing."):

    print(chunk, end="", flush=True)

```

If you want to try it out, here is the link to the Github repo:

[QV Ollama SDK]

Maybe this little helper is also helpful for you. Next I will build a super simple user interface with which we can interact with an LLM.

Until the next devlog, best regards

Thomas from the Quantyverse

Jetzt abonnieren

P.S.: Visit my website Quantyverse.ai for product, bonus content, blog posts and more

Self-doubt and uncertainty accompanied me - can I really do it? Isn't my vision too big? These questions have sometimes blocked me. Nevertheless, I am confident that I will steer Quantyverse in the right direction. The following description gives a first insight into my current vision.

"The Quantyverse will be a Multiverse powered by local AI. At the moment I am working on Quanty AI which is the entry point to this Universe. With Ollama as LLM Backend you create your own Companions which are animated Pixel Sprites, can use Agent SKILLS and you can interact with them in interactive Micro Fictions. I am currently expanding the Fictions, Gamify the whole experience and make it visually more appealing."

My goal is to create a fascinating AI-based universe based entirely on local AI - systems that run directly on a personal computer. This is a fusion of several of my passions: AI technology, systemic interactions, gaming, virtual worlds and storytelling.

I am aware that I do not yet have all the skills and complete knowledge to implement this project immediately. That's why I see it as an exciting journey of development. My blog should not only document my progress, but also provide insights and learning experiences for other interested parties.

My vision goes beyond a simple software project: I want to create a dynamic, interactive multiverse in which AI systems communicate with each other, generate their own stories and form a living virtual environment. An ecosystem that arouses curiosity and invites people to participate and explore.

I see myself as an Indie AI Developer . My goal is to create a place that is not only fun for me but also for you, in the hope that you will colonize the different worlds.

Greetings,

Thomas from the Quantyverse

P.S.: Visit my website Quantyverse.ai.

Jetzt abonnieren

In my opinion, what works in the gaming world can be transferred to indie AI developers.

It's about independent AI developers who develop creative applications away from the big tech companies. I definitely see potential here that needs to be exploited. We are all noticing how rapidly and inexorably technology is developing. These advances in AI - with increasingly sophisticated and compact models - allow us developers to work more efficiently and faster than ever before.

In concrete terms, this means that we have completely new opportunities to create and design things ourselves. The range of possibilities in which we can realize ourselves is huge. That's exactly why I want to go down the path of an independent AI developer and find my own niche.

At this point, let me briefly explain what the Quantyverse is all about: my focus is on local AI applications, with the aim of enriching immersive virtual experiences, such as video games, with local AI. Everything I develop revolves around the question: How can I use AI in a meaningful way?

Before I venture into more complex projects like games with AI-controlled characters or virtual avatars, I want to build a solid foundation. My goal is to develop a really good feel for the technologies. That's why I start with very basic Large Language Model (LLM) applications and build up different systems step by step - from RAG systems to crawlers and AI agents.

I will share my findings and developments with you on this blog. My hope is that you will find something here that will help you. Some of the applications will be open source, some will be free and some will also cost something.

For me, the Quantyverse is not a business idea, but a passion - a journey that I would like to take you on.

At this point, I would like to encourage you to just get started, even if you don't yet know exactly where the journey will take you. Over time, your inner picture of what you want to create will become clearer and clearer. This is still the case for me today: I am increasingly able to sense which topics appeal to me more and where my interests lie. The most important thing is to keep at it - even if it's only 30 minutes a day. Invest this time in something that will take you further.

Learn more about the things i build and use them at Quantyverse

Have fun developing!

Best regards

Thomas from the Quantyverse

Jetzt abonnieren

Introduction

The ui.Button is used to create interactive buttons in omni.ui. This tutorial will show you how to create buttons and handle button click events.

Check out the full Quantyverse´s Omniverse Guide at Quantyverse Tutorials

Prerequisites

• Basic understanding of Python.

• Nvidia Omniverse environment setup.

Creating a Basic Button

To create a button, you use the ui.Button class. Below is an example of how to create a basic button and handle a click event.

import omni.ui as ui

# Create a window
window = ui.Window("Button Example", width=300, height=200)

# Create a button inside the window
with window.frame:
    def on_button_click():
        print("Button clicked!")
    
    ui.Button("Click Me", clicked_fn=on_button_click)

Customizing a Button

You can customize a button by setting its text, icon, and other properties. Below is an example of how to create a button with a custom icon and text.

import omni.ui as ui
from omni.ui import color as cl

window = ui.Window("Customized Button", width=300, height=200)
with window.frame:
    def on_button_click():
        print("Styled button clicked!")
    
    ui.Button(
        "Styled Button",
        clicked_fn=on_button_click,
        style={"background_color": cl.('#097eff')}
    )

Summary

In this tutorial, we learned how to create and handle button click events in omni.ui. We covered the basics of creating a button and handling click events. Buttons are essential for creating interactive UI applications in Nvidia Omniverse, and mastering them will help you create more sophisticated and user-friendly interfaces.

AI-Assisted Learning

To enhance your learning experience, we're integrating our knowledge base into AI assistants across different platforms. Choose your preferred platform and start learning:

• CustomGPT: Quanty Omniverse Tutorials

• Poe: Quanty Omniverse Bot

Please note that both our knowledge base and AI assistants are continuously evolving. The AI's responses are based on the information we've provided, which means they may occasionally make mistakes or have gaps in their knowledge.

Thank you and I hope the Tutorial was helpful.

Thomas
Chief of Dreams and Omniverse Enthusiast, Quantyverse

Introduction

The ui.Label is one of the simplest and most commonly used UI elements in omni.ui. It is used to display text within your UI. In this tutorial, we will learn how to create and customize labels.

Check out the full Quantyverse´s Omniverse Guide at Quantyverse Tutorials

Prerequisites

• Basic understanding of Python.

• Nvidia Omniverse environment setup.

Creating a Basic Label

To create a label, you use the ui.Label class. Below is an example of how to create a basic label in a window.

import omni.ui as ui

# Create a window
window = ui.Window("Label Example", width=300, height=200)

# Create a label inside the window
with window.frame:
    ui.Label("Hello, Omniverse!")

Change the text of a label

You can change the text of a label by using the text property.

import omni.ui as ui

# Create a window
window = ui.Window("Label Example", width=300, height=200)

# Create a label inside the window
with window.frame:
    label = ui.Label("Hello, Omniverse!")
    label.text = "New Text"

Customizing a Label

You can customize a label by setting various properties. For example, you can change the text color, font size, and alignment.

import omni.ui as ui
from omni.ui import color as cl

# Create a window
window = ui.Window("Customized Label Example", width=300, height=200)

# Create a label inside the window
with window.frame:
    ui.Label("Customized Label", style={"font_size": 24, "color": cl("#097eff")})

Summary

In this tutorial, we learned how to create and customize labels in omni.ui. We covered the basics of creating a label, changing its text, and customizing its appearance. Labels are essential for displaying text in your UI applications, and mastering them will help you create more sophisticated and informative user interfaces.

AI-Assisted Learning

To enhance your learning experience, we're integrating our knowledge base into AI assistants across different platforms. Choose your preferred platform and start learning:

• CustomGPT: Quanty Omniverse Tutorials

• Poe: Quanty Omniverse Bot

Please note that both our knowledge base and AI assistants are continuously evolving. The AI's responses are based on the information we've provided, which means they may occasionally make mistakes or have gaps in their knowledge.

Thank you and I hope the Tutorial was helpful.

Thomas
Chief of Dreams and Omniverse Enthusiast, Quantyverse

The Omniverse Kit Software Development Kit (SDK) provides a robust framework for building applications within the Omniverse ecosystem. Understanding its core components is crucial for effective development. Let's explore the key elements that make up the Kit SDK.

!Check out the full Quantyverse´s Omniverse Guide at Quantyverse Tutorials!

Jetzt abonnieren

Kit Kernel Package

At the heart of the SDK lies the Kit Kernel Package, which serves as the central nervous system for Omniverse applications.

Key Features

1. Extension System

   • Manages the lifecycle of extensions, including loading, initialization, and shutdown.

   • Provides a plugin architecture for modular application development.

   • Handles dependencies between extensions.

2. Event System

   • Facilitates communication between different components of the application.

   • Implements a publish-subscribe model for efficient event handling.

   • Allows for loose coupling between modules, enhancing maintainability.

3. Update Loop

   • Ensures all components are updated appropriately throughout the application lifecycle.

   • Manages frame-by-frame updates for real-time applications.

   • Provides hooks for custom update logic in extensions.

Additional Kernel Features

4. Configuration System

   • Manages application and extension settings.

   • Supports runtime configuration changes.

Kit SDK Extensions

The Kit SDK includes a set of foundational extensions that provide essential functionality for Omniverse applications.

Highlighted Extensions

1. omni.usd

   • Provides synchronous and asynchronous interfaces to manage USD (Universal Scene Description) contexts.

   • Facilitates querying and modification of scene state.

   • Handles USD stage loading, saving, and live updates.

2. omni.kit.commands

   • Used to register and execute Commands within the application.

   • Implements undo/redo functionality for user actions.

   • Allows for the creation of custom commands for specific application needs.

3. omni.kit.viewport.window

   • Manages the Hydra-based viewport for 3D scene rendering.

   • Handles user interactions within the viewport, such as selection and camera controls.

   • Provides APIs for custom viewport manipulations and overlays.

4. omni.ui

   • The Omniverse UI framework for creating user interfaces.

   • Offers a wide range of UI elements and layouts.

   • Supports both 2D overlay UIs and 3D in-viewport interfaces.

Additional Important Extensions

5. omni.kit.menu

   • Manages application menus and context menus.

   • Allows for dynamic menu creation and modification.

6. omni.kit.property.usd

   • Provides property inspection and modification for USD objects.

   • Facilitates the creation of custom property editors.

7. omni.kit.window.extensions

   • Manages the extension browser and loader interface.

   • Allows users to view, enable, and disable extensions at runtime.

Relationships and Interactions

Understanding how these components interact is crucial for effective Omniverse development:

• The Kit Kernel acts as the foundation, managing the overall application lifecycle.

• Extensions build upon the Kernel, providing specific functionalities.

• The Event System allows extensions to communicate without direct dependencies.

• The Update Loop ensures all active extensions are updated each frame.

• USD serves as the common language for 3D data, with many extensions interacting with USD data.

Practical Application

To illustrate how these components work together, let's consider a simple scenario:

1. A user clicks a button in the UI (omni.ui) to add a cube to the scene.

2. This triggers a command (omni.kit.commands) to create a cube.

3. The command interacts with the USD stage (omni.usd) to add the cube geometry.

4. The viewport (omni.kit.viewport.window) is updated to display the new cube.

5. The property panel (omni.kit.property.usd) is refreshed to show the cube's attributes.

6. All of this is orchestrated by the Kit Kernel, which manages the extension lifecycles and update loop.

Conclusion

The Omniverse Kit SDK provides a powerful and flexible framework for building 3D applications. By understanding its core components and how they interact, developers can create sophisticated, performant, and extensible applications within the Omniverse ecosystem.

As you delve deeper into Omniverse development, you'll discover how these components can be leveraged and extended to create unique and powerful applications.

AI-Assisted Learning

To enhance your learning experience, we're integrating our knowledge base into AI assistants across different platforms. Choose your preferred platform and start learning:

• CustomGPT: Quanty Omniverse Tutorials

• Poe: Quanty Omniverse Bot

Please note that both our knowledge base and AI assistants are continuously evolving. The AI's responses are based on the information we've provided, which means they may occasionally make mistakes or have gaps in their knowledge.

Thank you and I hope the Tutorial was helpful.

Thomas
Chief of Dreams and Omniverse Enthusiast, Quantyverse

This guide will help you to create your first extension in the App you just created here Create Frist App / Setting up Environment

Check out the full Quantyverse´s Omniverse Guide at Quantyverse Tutorials

1. Create and Configure New Extension From Template

Run the following command to initiate the configuration wizard:

Linux:

./repo.sh template new

Windows:

.\repo.bat template new

Follow the prompt instructions:

• ? Select with arrow keys what you want to create: Extension

• ? Select with arrow keys your desired template: Basic Python Extension

• ? Enter name of application .kit file [name-spaced, lowercase, alphanumeric]: [set extension name]

• ? Enter application_display_name: [set extension display name]

• ? Enter version: [set extension version]

Note: You can choose between different Extension types like pure Python extension or Python UI extension which will have pre generated content tailored for the specific type. I recommend to have a look at these extensions.

2. Build the Extension

So the extension to be added to your app you have to build the application again, use the provided scripts according to your operating system:

• Windows:

.\repo.bat build

• Linux:

./repo.sh build

This command compiles the necessary components and prepares your environment for running the Omniverse applications with your new extension.

3. Launch the Application

After building the project, you can launch the application and see if your extension was created as expected:

• Windows:

.\repo.bat launch

• Linux:

./repo.sh launch

During the launch process, you'll be prompted to select the .kit file associated with your application, typically located in the _build directory.

4. Start your Extension

• Extension Manager: After launching, open the Extension Manager by navigating to Window > Extensions to explore and enable various extensions. Type the name of your extension you just created and start it.

5. Additional Resources

For more detailed instructions and advanced configuration options, refer to the official Omniverse Kit App Template documentation.

By following these steps, you'll have a fully functional extension you can now use to develop. Check out the other chapters on how to fill the extension with content.

AI-Assisted Learning

To enhance your learning experience, we're integrating our knowledge base into AI assistants across different platforms. Choose your preferred platform and start learning:

• CustomGPT: Quanty Omniverse Tutorials

• Poe: Quanty Omniverse Bot

Please note that both our knowledge base and AI assistants are continuously evolving. The AI's responses are based on the information we've provided, which means they may occasionally make mistakes or have gaps in their knowledge.

Thank you and I hope the Tutorial was helpful.

Thomas
Chief of Dreams and Omniverse Enthusiast, Quantyverse

This guide will help you set up your development environment for working with the Omniverse Kit App Template by creating your first Omniverse App. Following these steps will ensure that your environment is properly configured for building applications using Nvidia Omniverse.

1. Set Up the Required Tools

• Install Dependencies: Ensure your development environment is equipped with the latest version of Python. The Kit App Template is optimized for use with Visual Studio Code, though other IDEs like PyCharm can also be used.

• NVIDIA RTX GPU: Make sure your development machine has an NVIDIA RTX GPU with the latest drivers installed. This hardware is essential for running Omniverse applications efficiently.

2. Clone the Kit App Template Repository

Start by cloning the Kit App Template repository from GitHub to your local machine:

git clone https://github.com/NVIDIA-Omniverse/kit-app-template.git

Navigate into the cloned repository:

cd kit-app-template

3. Create and Configure New Application From Template

Run the following command to initiate the configuration wizard:

Linux:

./repo.sh template new

Windows:

.\repo.bat template new

Note: If this is your first time running the template new tool, you'll be prompted to accept the Omniverse Licensing Terms.

Follow the prompt instructions:

• ? Select with arrow keys what you want to create: Application

• ? Select with arrow keys your desired template: USD Composer or Kit Base Editor

• ? Enter name of application .kit file [name-spaced, lowercase, alphanumeric]: [set application name]

• ? Enter application_display_name: [set application display name]

• ? Enter version: [set application version]

4. Build the Project

To build the project, use the provided scripts according to your operating system:

• Windows:

.\repo.bat build

• Linux:

./repo.sh build

This command compiles the necessary components and prepares your environment for running the Omniverse applications.

5. Launch the Application

After building the project, you can launch the application:

• Windows:

.\repo.bat launch

• Linux:

./repo.sh launch

During the launch process, you'll be prompted to select the .kit file associated with your application, typically located in the _build directory.

6. Explore and Customize

• Extension Manager: After launching, open the Extension Manager by navigating to Window > Extensions to explore and enable various extensions. This allows you to extend the functionality of your application.

• Customization: Start by exploring and customizing the reference applications included in the template, such as the USD Explorer. This will help you understand how to configure and modify Kit-based applications.

7. Additional Resources

For more detailed instructions and advanced configuration options, refer to the official Omniverse Kit App Template documentation. You can also configure your environment to use community-developed extensions by adjusting the registry settings.

By following these steps, you'll have a fully functional development environment for creating and customizing applications within Nvidia Omniverse using the Kit SDK.

If you like to check out the full Quantyverse Omniverse Guide go here:
https://quantyverse.github.io/omniverse-tutorials/index.html

or check out the repository here:
https://github.com/quantyverse/omniverse-tutorials

Hope it helps you!

Thomas
Chief of Dreams and Omniverse Enthusiast, Quantyverse

What is omni.ui?

omni.ui is a flexible and powerful framework in Omniverse for building user interfaces. It provides a wide range of widgets, layout management, and customization options, allowing you to create sophisticated and interactive UIs tailored to your application's needs.

Step 1: Setting Up Your Development Environment

Before diving into UI creation, ensure that your Omniverse development environment is set up. You can follow the guideline here: https://github.com/NVIDIA-Omniverse/kit-app-template. But I am also going to create a Tutorial on how to setup your own application. Make sure to create an extension and open it in your IDE of choice so you can follow along.

Step 2: Creating a New UI Window

Start by creating a new window that will house your UI elements. This is done by instantiating a Window object in your extension's Python script.

python
import omni.ui as ui
import omni.ext

class MyExtension(omni.ext.IExt):
    def on_startup(self, ext_id):
        self._window = ui.Window("My Window", width=400, height=300)
        with self._window.frame:
            self._build_ui()

This code snippet creates a window titled "My Window" with a specified width and height. The - with self._window.frame: - block is where you'll build the actual UI.

Step 3: Building the UI Layout

Next, define the layout for your UI components. Omniverse offers various layout containers such as VStack (Vertical Stack), HStack (Horizontal Stack), and Grid. These help organize your UI elements effectively.

def _build_ui(self):
    with ui.VStack():
        ui.Label("Welcome to Omniverse!")
        ui.Button("Click Me", clicked_fn=self._on_button_click)

In this example, a vertical stack is used to align a label and a button. The clicked_fn parameter links the button to a callback function that handles the click event.

Step 4: Adding Interactivity with Widgets

Omniverse's omni.ui provides a wide range of widgets that you can add to your UI, such as sliders, checkboxes, text fields, and more.

def _on_button_click(self):
    print("Button clicked!")

Here we have the callback function for our ui.Button.

Step 5: Advanced Layouts and Widgets

For more complex UIs, you can use advanced widgets and layouts. For example, CollapsableFrame allows sections of your UI to be collapsed or expanded, which is useful for organizing large UIs. Or ScrollingFrame to make your UI scrollable

with ui.ScrollingFrame():
    with ui.VStack():
        with ui.CollapsableFrame("Advanced Settings"):
            ui.Label("Adjust the parameters below:")
            ui.Button("Push the button")

Step 6: Testing and Debugging

Omniverse supports hot-reloading, which means you can test your UI in real-time as you develop it. This is invaluable for iterating on your design quickly. Make sure to test your UI thoroughly to ensure it behaves as expected.

Step 7: Finalizing and Distributing Your Extension

Once your UI is complete and tested, package your extension for distribution or use within the Omniverse platform.

Conclusion

Creating a user interface in Omniverse using omni.ui is a straightforward process thanks to the framework's powerful features and flexibility. I have to admit that some advanced features are not intuitive but when you get the hang on it you can craft nice UI pretty fast.

You can find all Tutorials als on my Github

Thomas
Chief of Dreams & Omniverse Enthusiast, Quantyverse

Hey there, Quantyverse explorers! Thomas here, and today we're diving into a topic that's got me buzzing with excitement: Godot and its potential to revolutionize the game industry as an open ecosystem.

The Rise of the Underdog

First things first, let's talk about Godot's meteoric rise. This plucky little engine has been growing at 60-80% year over year (While overall still much less games then Unity or Unreal Engine). To put that in perspective, while the big players like Unity and Unreal have a about 5% growth, Godot is practically taking off like a rocket (Rates should increase over the years)! At this rate, we could be looking at Godot matching Unity's numbers on Steam by 2028.

Breaking Free from the Chains of Proprietary Platforms

Now, I know what you're thinking. "Thomas, haven't we always had choices in game engines?" Well, yes and no. The problem with proprietary engines is that they're like a double-edged sword. They give you the tools, but at a cost – and I'm not just talking about money.

When you build on a proprietary platform, you're always at the mercy of the company that owns it. They can change the rules, alter the pricing, or even decide to compete with you using the very platform you're building on. It's like building your dream house on rented land – you never truly own your creation.

The Linux of Game Development

This is where Godot comes in, wearing its open-source cape and ready to save the day. Think back to the 90s (if you're old enough – if not, just imagine with me). Linux was this scrappy little OS that nobody in the corporate world took seriously. Fast forward to today, and it's the backbone of enterprise computing.

Godot is poised to do the same for game development. By being truly open.

Building Castles, Not Just Tools

The potential here is enormous. When you build on an open ecosystem like Godot, you're not just making a game or a tool. You're potentially creating entire new platforms. With an open ecosystem, you're free to innovate, expand, and create without fear of the rug being pulled out from under you.

The key here is integration. Don't just support Godot – build on it. Create services and tools that are so deeply integrated with Godot that using them becomes a no-brainer for developers. This is how we'll see the real magic happen.

The Power of Community

One of the most beautiful things about open ecosystems is the community that forms around them. Godot isn't owned by a single entity – it's owned by all of us. This means that when you contribute to Godot, when you build on it, you're not just helping some faceless corporation. You're empowering every single developer who uses the engine.

This community-driven development leads to incredible innovation. Problems get solved faster, features get implemented quicker, and the entire ecosystem benefits.

The Future is Open

As we look to the future of game development, one thing is clear: openness is the way forward.

Imagine a world where game development tools, services, and platforms all work seamlessly together, built on an open foundation. Where small indie devs and large studios alike can innovate without fear of platform lock-in. That's the world Godot is helping to create.

Your Call to Adventure

So, my fellow Quantyverse explorers, here's my challenge to you: don't just use Godot – embrace it. Build on it. Create the tools, services, and platforms that will shape the future of game development. Whether you're a solo dev working on your passion project or a company looking to create the next big gaming platform, Godot and the open ecosystem it represents are your tickets to true creative freedom.

Until next time, keep dreaming, keep coding, and keep pushing the boundaries of what's possible in our ever-expanding digital multiverse!

Thomas
Chief of Dreams & Open Ecosystem Enthusiast, Quantyverse

P.S. Got thoughts on the open ecosystem revolution? Exciting ideas for Godot-based tools or services? Drop them in the comments below. Let's brainstorm the future of game development together!

Hey there, Quantyverse explorers! Thomas here, and today we're diving into a magical realm that's going to be powering a big chunk of our Quantyverse dreams: the Godot Game Engine. Get ready for a code-fueled adventure!

Imagine standing at the edge of a vast digital frontier, armed with nothing but your imagination and a burning desire to create. Suddenly, a friendly robot named Godot appears (okay, it's just a logo). This little bot hands you a Swiss Army knife of game development tools, all wrapped up in an open-source bow. That, my friends, is the Godot Engine in a nutshell.

Now, why am I geeking out about Godot in our Quantyverse playground? Simple. It's like finding the perfect dance partner for our multiversal ball. Godot's flexibility, community-driven spirit, and "anyone can make games" philosophy align perfectly with what we're building here in the Quantyverse.

Let's break it down

First off, Godot is open-source. This open nature is going to save you a few bucks in the long run (who doesn't love that?). And it is about fostering a community of creators who share, learn, and grow together.

But here's where it gets really juicy for us Quantyverse dreamers: Godot plays nice with others. Remember our chats about NVIDIA Omniverse and Universal Scene Description (USD)? Well, Godot is like that friend who gets along with everyone at the party. With a bit of elbow grease and some coding magic, we can potentially create bridges between Godot and our other Quantyverse tools. Imagine designing a character in Blender, tweaking it in Substance Painter, and then bringing it to life in a Godot game – all within our Quantyverse ecosystem! So this is also one party of future development. A fully grown Godot Omniverse Connector.

So, where does this leave us in the grand Quantyverse scheme? Well, imagine Godot as one of the powerful artifacts in our creator's toolkit. It's a way to bringing our funniest game ideas to life. The games and experiences we create with Godot could become vibrant planets in our ever-expanding Quantyverse.

Here's my challenge to you, my fellow Quantyverse pioneers: take Godot for a spin. Download it, open up a tutorial, and try creating something – anything! A bouncing ball, a simple platformer, or even just a interactive story. Share your creations, your triumphs in the comments below.

Remember, in the Quantyverse, we're not just game developers or storytellers or AI enthusiasts – we're dream weavers.

Until next time, keep those creative engines running!

Thomas
Chief of Dreams & Godot Grappler, Quantyverse

P.S. Stuck on a Godot puzzle? Drop your questions below, and let's solve it together. After all, in the Quantyverse, no developer debugs alone!

Hey Quantyverse explorers! Thomas again and ready to bring some light on a crucial piece of our multiverse puzzle: NVIDIA Omniverse Connectors. These digital bridges are an important part to bring our Quantyverse dreams to life, so let's dive in!

What's the Deal with Omniverse Connectors?

Omniverse Connectors aren't about creating a multiverse - that's our job as creators. Instead, think of them as highly specialized translators. Their purpose? To ensure that Substance Painter, Unreal Engine, and other powerhouse 3D tools can chat freely with Omniverse and our very own QuantyVerse Nexus (in Universal Scene Description).

Why Connectors Matter for the Quantyverse

1. Seamless Asset Flow: Let´s say you created a wonderful texture in Substance Painter. With connectors, it slides right into your Omniverse scene without breaking a sweat.

2. Real-time Updates: Tweak a material in Substance Painter, and watch it update in real-time within QuantyVerse Nexus.

3. Universal Asset Usage: Create once, use everywhere. Your Unreal Engine environments can now easily become part of your Quantyverse worlds in other 3D Tools like Unity. If licensing of the Assets are okay.

4. Streamlined Workflow: No more endless import/export cycles. Connectors keep your creative flow flowing.

Connectors and QuantyVerse Nexus: A Match Made in Digital Heaven

As we're building QuantyVerse Nexus, connectors are becoming our best friends. Here's why:

• Diverse Toolset Integration: Whether you're a Substance Painter texture wizard or an Unreal Engine landscape guru, your skills and creations have a place in QuantyVerse Nexus.

• Future-Proofing: As new tools emerge, connectors will help us stay adaptable, ensuring QuantyVerse Nexus remains well connected.

Your Creative Input Needed!

Now it's your turn to chime in:

• Which 3D tools are essential to your creative process?

• How could easier data exchange between your favorite software and QuantyVerse Nexus enhance your workflow?

• Any ideas for integrating diverse 3D tools into the Quantyverse ecosystem?

Share your thoughts below.

Keep creating, keep dreaming, and keep pushing those digital boundaries. Together, we're building bridges to new realms of creativity!

Thomas
Chief of Dreams & Integration Enthusiast, Quantyverse

P.S. Curious about which connectors are currently available? Check out NVIDIA's official list.

Hey there its me again, Thomas! Today, we're diving into the heart of what's making our Quantyverse visions a reality: Universal Scene Description (USD) and its game-changing role in NVIDIA Omniverse.

Breaking Down Barriers in the 3D Realm

Ever tried to build an epic digital world, only to find your 3D assets refusing to play nice with each other? It's like trying to host a dinner party where none of your guests speak the same language. And here comes USD - the ultimate universal translator for the 3D world. The so called HTML for 3D Worlds.

Basically it´s a language that allows different 3D applications to communicate seamlessly inside NVIDIA Omniverse. So the conversion from Blender to Substance Painter to Unreal Engine flows like honey on your morning toast.

It's creating an entire ecosystem where 3D assets can coexist, interact, and evolve together. It's like giving a shared consciousness to your digital creations and watching them come alive!

NVIDIA Omniverse: USD's Playground of Infinite Possibilities

Now, let's talk about NVIDIA Omniverse for a second again. If USD is the universal language, Omniverse is the ultimate sandbox of your childhood dreams.

With Omniverse, we're not just creating static 3D scenes anymore. We're building dynamic, responsive worlds that can be manipulated in real-time. Adjust the lighting in your scene? It updates across all connected applications instantly. Tweak a character's hair? Watch it reflect everywhere in the blink of an eye.

For us Quantyverse visionaries, this opens up a universe of possibilities:

1. Collaborative Worldbuilding: Work on a Quantyverse project with a friend on the other side of the planet, seeing their changes materialize in real-time. It's like a jam session for world creators!

2. Asset Reusability: That sci-fi spaceship you poured your heart into? Now it can voyage between different software, projects, and universes without breaking a sweat.

3. AI Integration: Omniverse's compatibility with Python means we can weave AI tools into our creative process. Imagine procedurally generated worlds that evolve based on AI-driven tools!

The Quantyverse Dream Realized

But what are we doing now with this information ? Well, my friend, this is where our QuantyVerse Nexus comes into play.

With USD as our foundation and Omniverse as our canvas, we want to create a gateway to limitless creativity. Want to design a world with just your hand-drawn map? Upload and Done. Dreaming of a universe where thoughts take physical form? Let's bring it to life!

Charting the Course Ahead

The thing is that the QuantyVerse Nexus is not finished and in really early stage. I am working on it and when there is a first crappy version I will let you know! Have question? Just ask!

Your Turn to Shape the Quantyverse

Now it's your time to shine, fellow explorers of the digital frontier. I want to hear your thoughts:

• What kinds of interconnected realms would you craft with this technology?

• How do you envision USD and Omniverse revolutionizing the landscape for digital creators?

• Got any out-of-this-world ideas for features in our QuantyVerse Nexus that could harness this tech?

Share your ideas in the comments. Who knows? Your wild concept might just become the next groundbreaking feature in the Quantyverse!

Until our next digital meetup, keep pushing the boundaries of what's possible in our ever-expanding digital multiverse!

Thomas
Chief of Dreams & USD Enthusiast, Quantyverse

Hey there, Quantyverse dreamers! Thomas here, and I've got something that's making my ears smoke from Berty Botts Beans. Remember how I mentioned NVIDIA Omniverse in the last Blog Post?

The "Aha!" Moment

You know those moments in sci-fi movies where the protagonist stumbles upon a piece of alien tech that changes everything? That's exactly how I felt when I first got my hands on NVIDIA Omniverse at my day-job. I always dreamed of creating interconnected multiverses and talked about USD even before NVIDIA Omniverse was even born. With a rush it flew into my life like a digital superhero with its cape flowing in the wind of rendering processors. Suddenly I had the strong believe that this piece of tech is going to make my imaginations a reality.

What´s the Big Deal?

Now, I could bore you with technical jargon, but let's cut to the chase. Omniverse is like the ultimate universal translator, but for 3D content and simulations. It's the bridge between different software, different creators, and different ideas.

Here's why it's a game-changer for us:

1. Universal Language: No more "this file doesn't work with that software" headaches. Omniverse can speak the language of pretty much every 3D tool out there through the use of Universal Scene Description (USD).

2. Real-time Collaboration: Imagine working on a Quantyverse world with a friend halfway across the globe, and seeing their changes appear in real-time. It's like multiplayer world-building!

3. Physics That Make Sense: Want to know how your character's epic cape could flow in the wind? Or simulate your world for some reason in Omniverse? All this is possible.

4. AI Playground: This is where it gets even better. Omniverse speaks Python. So it plays nice with AI, opening up to endless possibilites of creating tools for creation.

The Road Ahead

Now, I know based on my experience - there's a learning curve here. Omniverse is powerful, but with great power comes... a sh*t load of work. Over the next few weeks, I'll be jumping into this tech, and I'll be sharing every triumph, fall, and "oh no, what did I just do?" moment with you all.

Your Mission, Should You Choose to Accept It

Here's where you come in, my fellow Quantyverse explorers. I want to hear from you:

1. What kind of worlds would you create if you had the power of Omniverse at your fingertips?

2. How do you see AI fitting into this new paradigm of world-building?

3. Are there any specific features you'd love to see in our QuantyVerse Nexus?

Drop your ideas in the comments. Who knows? Your wild idea might just become the next big feature in Quantyverse!

Until next time, keep dreaming in high-res, full-color and ultimate 3D!

Thomas
Chief of Dreams & Omniverse Dancer, Quantyverse

Jetzt abonnieren

P.S. If you're itching to get your hands on Omniverse, NVIDIA has some great tutorials. Check them out, and let's geek out together in our next community meetup!