Getting Started with Project G-Assist: Build...

Getting Started with Project G-Assist: Build...

Today, tweaking your PC to suit your workflows often involves digging through menus and settings across multiple control panels. Project G-Assist is an experimental on-device AI assistant designed to help users control their RTX GPU and other PC settings using a natural language interface. G-Assist can execute common NVIDIA App commands, optimize performance, monitor performance statistics, and much more. Plus, G-Assist can be used while you’re gaming or creating thanks to the NVIDIA App Overlay, without having to alt-tab. 

Most importantly, G-Assist can be extended by the community via plug-ins to control other hardware or apps in your PC, such as your mouse settings, what’s playing on Spotify, or even your smart devices with IFTTT. 

G-Assist provides an accessible way to build AI-powered routines on your PC. It provides the infrastructure, including a small language model (SLM) that can run locally, and the developer just has to provide the functions it wants to trigger. This is made even simpler thanks to a GPT-based Plug-in Builder. 

In this blog post, we’ll show you how you can create your own G-Assist plug-in using a Twitch integration as an example. You’ll learn how plug-ins work, how they communicate with G-Assist, and how to build your own from scratch. Whether you’re a Python dev, C++ enthusiast, or just getting started, we’ve got tools and templates to make plug-in development fast and approachable.

diagram showing the framework for NVIDIA Project G-Assistdiagram showing the framework for NVIDIA Project G-Assist
Figure 1. Project G-Assist sample function-calling assistant framework

What are G-Assist plug-ins?

G-Assist plug-ins are add-ons that define new functionality so G-Assist users can invoke these plug-ins through natural language using a SLM with simple voice or text prompts.

Plug-in commands are fully user-defined and interpreted by the SLM at inference time using a simple manifest format. You can write them in Python or C++ using the templates we’ve provided on GitHub. With minimal setup, you can create your own voice and text-accessible tools — from performance analyzers to smart home routines.

Video 1. How to create a Project G-Assist plug-in
  • GPT Plug-in Builder: A custom GPT we built to vibe code with you. Generate plug-in code and files, discover APIs and capabilities, or ‌help you brainstorm plug-in functionality. 
  • Plug-in templates (Python and C++): Pre-built templates that set up the plug-in structure, configuration, communication logic, and function definitions for you.

Plug-in examples: A growing list of plug-in examples including Twitch, Discord, Nanoleaf, IFTTT integrations, and more — all available as open source projects.

Twitch plug-in: Check if a streamer is live

Let’s look at a real example. This plug-in checks whether a Twitch streamer is currently live and returns stream details like title, game, viewer count, and start time.

Example responses:

ninja is LIVE!
Title: Friday Fortnite!
Game: Fortnite
Viewers: 45,231
Started At: 2024-03-14T12:34:56Z

Or:

Requirements

To build the plug-in, you’ll need:

  • Python 3.12 installed on your system
  • A Twitch Developer App (to get your client ID and secret)
  • The G-Assist Python plug-in template from GitHub

Plug-in structure

Your plug-in will include four key files:

1. manifest.json

Defines the plug-in’s available functions and parameters, used by G-Assist to understand what the plug-in can do. The function and parameter descriptions help the G-Assist SLM understand how to match user input to the correct function and determine what parameters are needed to execute it.

{
  "manifestVersion": 1,
  "executable": "g-assist-plug-in-twitch.exe",
  "persistent": false,
  "functions": [
    {
      "name": "check_twitch_live_status",
      "description": "Checks if a Twitch user is live and retrieves stream details.",
      "tags": ["twitch", "live_status"],
      "properties": {
        "username": {
          "type": "string",
          "description": "The Twitch username to check."
        }
      }
    }
  ]
}

2. config.json

Contains your Twitch Client ID and Secret, which are required to authenticate with the Twitch API. This file should never be shared, as it holds sensitive credentials. Since the plug-in directory is admin-restricted, the file remains secure on your system.

{
  "TWITCH_CLIENT_ID": "your_client_id_here",
  "TWITCH_CLIENT_SECRET": "your_client_secret_here"
}

3. plug-in.py

Contains all plug-in logic: Authentication, API requests, parsing responses, and communication with G-Assist via Windows named pipes.

Here’s the main loop:

def main():
    setup_logging()
    logging.info("Twitch Plugin Started")

    while True:
        command = read_command()
        if command is None:
            continue

        for tool_call in command.get("tool_calls", []):
            func = tool_call.get("func")
            params = tool_call.get("params", {})
            if func == "check_twitch_live_status":
                response = check_twitch_live_status(params)
                write_response(response)
            elif func == "shutdown":
                return

Commands are JSON-formatted messages like this:

{
  "tool_calls": [{
    "func": "check_twitch_live_status",
    "params": {
      "username": "nvidia"
    }
  }]
}

Responses must include a success flag and message string. G-Assist supports Markdown formatting:

{
  "success": true,
  "message": "nvidia is LIVE!\nTitle: NVIDIA Gaming Stream\nGame: Cyberpunk 2077\nViewers: 1234"
}>

Windows named pipe communication

G-Assist and your plug-in communicate using Windows “named pipes”. Input commands are sent to the plug-in as JSON messages, and responses must be written back in the same format — with > appended to signal the end of a response.

Both read_command and write_response are included in the plug-in template. read_command reads in chunks to support large inputs. write_response formats the output and appends the required end tag. The transport layer is abstracted away, leaving you to focus on command handling.

Twitch API integration

To talk to Twitch, we use the OAuth 2.0 client credentials flow:

def get_oauth_token():
    try:
        response = requests.post(
            TWITCH_OAUTH_URL,
            params={
                "client_id": config.get("TWITCH_CLIENT_ID"),
                "client_secret": config.get("TWITCH_CLIENT_SECRET"),
                "grant_type": "client_credentials"
            }
        )
        return response.json().get("access_token")
    except Exception as e:
        logging.error(f"Error getting OAuth token: {e}")
        return None

Once we have a token, we check if the user is live:

def check_twitch_live_status(params: Dict[str, str]):
    username = params.get("username")
    oauth_token = get_oauth_token()

    headers = {
        "Client-ID": config.get("TWITCH_CLIENT_ID"),
        "Authorization": f"Bearer {oauth_token}"
    }

    response = requests.get(
        TWITCH_STREAM_URL,
        headers=headers,
        params={"user_login": username}
    )

    data = response.json().get("data", [])
    if data:
        stream = data[0]
        return {
            "success": True,
            "message": (
                f"{username} is LIVE!\n"
                f"Title: {stream['title']}\n"
                f"Game: {stream.get('game_name', 'Unknown')}\n"
                f"Viewers: {stream['viewer_count']}"
            )
        }
    return {"success": True, "message": f"{username} is OFFLINE"}

More plug-in ideas

You’ll find many more plug-in examples on our GitHub, each showcasing different ways to extend G-Assist.

  • IFTTT plug-in: Trigger smart home routines with simple voice or text commands — like saying, “It’s game time!” to activate a custom routine.
  • Discord plug-in: Send messages, images, or videos to a Discord channel using a bot you configure. You can also extend it to check friend status, game activity, or post to specific channels.
  • Nanoleaf plug-in: Control your Nanoleaf lighting over IP — set colors and adjust brightness from the G-Assist chat. Future improvements could include support for custom profiles, reading current device state, and managing multiple lights.

Each example highlights different integration patterns and is fully open sourced for you to explore, customize, and build on.

Enter our Plug and Play Hackathon by July 16

To join our Plug and Play: Create a Project G-Assist Plug-in Hackathon, register here. Once you’ve registered, build a custom G-Assist plug-in that adds new commands, connects external tools, and uses AI workflows tailored to specific needs — enabling on-device, AI-assisted functionality that responds to text or voice commands. Finally, submit your plug-in to our submission form here (see requirements on our Plug and Play page). 

The best plug-in entries have a chance to win an NVIDIA GeForce RTX 5090 laptop, NVIDIA GeForce RTX 5080 GPU, or NVIDIA GeForce RTX 5070 GPU.

The hackathon runs from today until July 16, 2025.

Our goal is to make plug-in creation open and collaborative. You’ll find templates, full examples, and documentation on our G-Assist GitHub.

Have questions about your plug-in or want to learn more? Register and join us for our webinar RTX AI Workshop: How to Build a Project G-Assist Plug-In on July 9, 2025 to hear from NVIDIA and ask questions about your plug-in projects. 

You can also join our Discord to share your creations, join G-Assist conversations, and get help from our community or from NVIDIA experts directly.