Take an Interactive Journey Through America’s National Parks with AI Tools

Take an Interactive Journey Through America’s National Parks with AI Tools

America’s national parks have long inspired a sense of wonder, but not everyone can pack a camping stove and head to Yosemite or Acadia on a whim. In August 2026, Google Arts & Culture launched a remarkable project called United Parks of America, designed to let people explore these protected landscapes from anywhere in the world. The initiative is an excellent example of how AI can turn a static screen into a rich, interactive environment—let visitors “walk” through trails, zoom into geological details, and hear the stories behind the monuments.

But you don’t have to wait for a tech giant to build your experience. With a few open-source tools and public datasets, you can create your own interactive journey through America’s national parks. This article walks through a practical, hands-on project: a command-line and web-based app that fetches park data, generates descriptive text, and even produces AI-powered image captions. It’s a perfect weekend project for developers who want to combine their love of nature with a bit of machine learning.

Requirements

Before we begin, make sure you have the following on your machine:

• Python 3.9 or higher – we’ll use modern language features and recent library versions.
• pip – the standard Python package installer, usually bundled with Python.
• A stable internet connection – we need to download datasets and pre-trained models.
• A National Park Service (NPS) API key – free to obtain at developer.nps.gov. This is a public web service that provides official information about all national parks, including descriptions, activities, and coordinates.
• A GPU (optional but recommended) – if you plan to run a vision-language model locally, a GPU will speed up inference. However, CPU execution works fine for small examples.

No knowledge of frontend development is required; we’ll use Gradio, a Python library that turns a few lines of code into a shareable web interface.

Step-by-step installation

First, set up a clean Python environment to avoid dependency clashes with other projects. Open your terminal and create a virtual environment.

python -m venv nps-env

Activate it. On macOS and Linux:

source nps-env/bin/activate

On Windows, the command is slightly different:

nps-env\Scripts\activate

Now upgrade pip to the latest version and install the libraries we need.

pip install --upgrade pip
pip install requests pandas pillow torch transformers gradio

Here’s what each library does:

• requests – makes HTTP calls to the NPS API.
• pandas – organizes the returned JSON data into tables.
• pillow – processes images.
• torch – PyTorch, the engine behind many AI models.
• transformers – Hugging Face’s library to load pre-trained language and vision models.
• gradio – builds a web interface for our tool.

After installation, verify everything worked by printing the versions.

python -c "import torch; print(torch.__version__); import gradio; print(gradio.__version__)"

Now create a project folder and a Python script. We’ll call it nps_journey.py.

mkdir nps-journey
cd nps-journey

Fetching national park data

The National Park Service provides a well-documented API. To access it, you need an API key. Once you have it, save it in an environment variable for security.

export NPS_API_KEY="your-api-key-here"

Now we’ll write a script that requests a list of parks and displays their names. Open nps_journey.py in a text editor and add:

import os
import requests
import pandas as pd

API_KEY = os.getenv("NPS_API_KEY")
BASE_URL = "https://developer.nps.gov/api/v1/parks"

def fetch_park_data(limit=50):
    headers = {"X-Api-Key": API_KEY}
    params = {"limit": limit, "fields": "images,activities"}
    response = requests.get(BASE_URL, headers=headers, params=params)
    response.raise_for_status()
    data = response.json()
    return pd.DataFrame(data["data"])

parks_df = fetch_park_data()
print(parks_df[["name", "states"]].head())

Run the script to see a list of national parks and the states they reside in.

python nps_journey.py

You’ll get a table with at least the first 50 parks. We now have the raw material for our interactive journey.

Building the interactive shell

A simple command-line menu is a good start. We can ask the user to choose a park and then show its description, activities, and hours. Let’s expand our script:

def get_park_details(park_code):
    headers = {"X-Api-Key": API_KEY}
    params = {"parkCode": park_code}
    response = requests.get(BASE_URL, headers=headers, params=params)
    response.raise_for_status()
    data = response.json()["data"]
    if not data:
        return None
    return data[0]

def interactive_cli():
    while True:
        print("\nAvailable parks (first 10):")
        sample = parks_df.head(10)[["parkCode", "name"]].to_string(index=False)
        print(sample)
        code = input("Enter a park code (or 'q' to quit): ").strip().lower()
        if code == "q":
            break
        park = get_park_details(code)
        if park is None:
            print("Park not found. Try again.")
            continue
        print(f"\n{park['name']}")
        print(park.get("description", "No description available."))
        print("\nActivities:", ", ".join(
            [a["name"] for a in park.get("activities", [])]
        ))
        print("\nWeather info:", park.get("weatherInfo", "Not available."))

if __name__ == "__main__":
    interactive_cli()

Now we can navigate the parks directly from the terminal. But to make this truly interactive and visual, let’s leverage a web interface.

Usage examples

Example 1: A Gradio dashboard for park exploration

Gradio is the fastest way to turn your Python script into a shareable web app. We’ll create a function that takes a park code and returns a structured view of the park’s essentials.

import gradio as gr

def display_park(park_code):
    park = get_park_details(park_code)
    if park is None:
        return "Park not found", None
    if park.get("images"):
        img_url = park["images"][0]["url"]
    else:
        img_url = None
    description = park.get("description", "")
    activities = ", ".join([a["name"] for a in park.get("activities", [])])
    info = f"**Park:** {park['name']}\n\n{description}\n\n**Activities:** {activities}"
    return info, img_url

Then we launch the app:

demo = gr.Interface(
    fn=display_park,
    inputs="text",
    outputs=["markdown", gr.Image(type="filepath")],
    title="Interactive National Parks Explorer",
    description="Enter a park code (e.g., YOSE for Yosemite) to explore."
)
demo.launch()

Run the script and open the local URL in your browser. You just built a web-based interactive explorer that gives you official NPS information and images. That’s a solid foundation for a “journey.”

Example 2: AI-powered image captioning

Now comes the AI edge. The project from Google Arts & Culture gives a hint at the power of generative AI: it can invite you into a landscape through multiple senses. We can emulate that feeling with a pre-trained vision-language model that describes any image you throw at it.

Hugging Face’s transformers library includes models like BLIP (Bootstrapping Language-Image Pre-training). Here’s how to load it and get a description of a park photo.

from transformers import pipeline

def load_captioner():
    return pipeline("image-to-text", model="Salesforce/blip-image-captioning-large")

captioner = load_captioner()

def caption_image(image_path):
    result = captioner(image_path)[0]["generated_text"]
    return result

Let’s combine this with the park explorer. When a user selects a park, we take the first image from the NPS API, save it to a temp file, and generate a poetic caption with BLIP.

import tempfile
import requests
from PIL import Image

def download_image(url, save_path):
    response = requests.get(url, stream=True)
    response.raise_for_status()
    with open(save_path, "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)

def display_park_with_caption(park_code):
    park = get_park_details(park_code)
    if park is None or not park.get("images"):
        return "Park or image not found", None
    img_url = park["images"][0]["url"]
    temp_path = tempfile.NamedTemporaryFile(suffix=".jpg", delete=False).name
    download_image(img_url, temp_path)
    caption = caption_image(temp_path)
    info = f"**{park['name']}**\n\n{caption}\n\nDescription: {park.get('description', '')}"
    return info, temp_path

Now launch a new Gradio interface:

demo2 = gr.Interface(
    fn=display_park_with_caption,
    inputs="text",
    outputs=["markdown", gr.Image(type="filepath")],
    title="AI-Powered National Park Journey",
    description="Enter a park code and let AI interpret the view."
)
demo2.launch()

This is a small taste of the interactive journeys mentioned in the Google Arts & Culture project. Instead of just reading facts, the user is given an AI-generated interpretation of what the place looks like. You can even extend the idea further—generate a short poem, create a travel itinerary based on the park’s activities, or summarize visitor reviews.

Example 3: A route planner using park coordinates

Most NPS records include latitude and longitude. We can use that to build a map-based journey. For simplicity, we’ll show the coordinates and compute distances between two parks. This is a practical feature for people who want to plan a multi-park road trip.

from math import radians, sin, cos, sqrt, atan2

def haversine(lat1, lon1, lat2, lon2):
    R = 6371
    dlat = radians(lat2 - lat1)
    dlon = radians(lon2 - lon1)
    a = sin(dlat / 2) ** 2 + cos(radians(lat1)) * cos(radians(lat2)) * sin(dlon / 2) ** 2
    return 2 * R * atan2(sqrt(a), sqrt(1 - a))

def distance_between_parks(code1, code2):
    park1 = get_park_details(code1)
    park2 = get_park_details(code2)
    if not park1 or not park2:
        return "Invalid park code."
    lat1, lon1 = park1["latitude"], park1["longitude"]
    lat2, lon2 = park2["latitude"], park2["longitude"]
    dist = haversine(float(lat1), float(lon1), float(lat2), float(lon2))
    return f"Distance from {park1['name']} to {park2['name']}: {dist:.0f} km"

Add the function to the existing Gradio app, and visitors can explore the geography behind the experience. It’s an instant “where am I going next” tool.

Example 4: Generating a personalized itinerary

The NPS API also provides a list of activities, but we can take it a step further and use a language model to create a one-day itinerary based on those activities. For instance, we can use a lightweight text generation model from Hugging Face, such as distilgpt2, to write a paragraph describing a hike through the park. This isn’t a fully reliable factual itinerary, but it gives a creative immersive flavor.

from transformers import pipeline

def generate_itinerary(park_code):
    park = get_park_details(park_code)
    if not park:
        return "Park not found."
    activities = [a["name"] for a in park.get("activities", [])]
    prompt = (
        f"Imagine a day in {park['name']}. "
        f"It offers: {', '.join(activities[:5])}. "
        f"Write a short itinerary in two sentences."
    )
    text_gen = pipeline("text-generation", model="distilgpt2")
    result = text_gen(prompt, max_new_tokens=80, num_return_sequences=1)[0]["generated_text"]
    return result

Combine this with the previous functions, and you have a fully interactive journey with three levels of AI assistance: factual data, visual description, and creative narrative. That mirrors the spirit of the United Parks of America project: making the parks feel alive, even from afar.

Putting it all together

Let’s combine everything into a single Gradio app with tabs, so you can switch between the classic explorer, the image captioner, the distance calculator, and the AI itinerary writer.

with gr.Blocks() as full_app:
    gr.Markdown("# 🏞 Take an AI Journey Through America’s National Parks")
    with gr.Tab("Explore"):
        code_input = gr.Textbox(label="Park code")
        out_text = gr.Markdown()
        out_img = gr.Image(type="filepath")
        explore_btn = gr.Button("Go")
        explore_btn.click(fn=display_park_with_caption, inputs=code_input, outputs=[out_text, out_img])
    with gr.Tab("Distance"):
        code1 = gr.Textbox(label="Park 1 code")
        code2 = gr.Textbox(label="Park 2 code")
        dist_out = gr.Markdown()
        dist_btn = gr.Button("Compute")
        dist_btn.click(fn=distance_between_parks, inputs=[code1, code2], outputs=dist_out)
    with gr.Tab("Itinerary"):
        code_it = gr.Textbox(label="Park code")
        it_out = gr.Markdown()
        it_btn = gr.Button("Generate")
        it_btn.click(fn=generate_itinerary, inputs=code_it, outputs=it_out)
full_app.launch()

Run the script again and you’ll have a local interactive portal. Share the local URL with friends, or deploy it on a free service like Hugging Face Spaces (remember to set your NPS API key as a secret there).

Notes and limitations

The tools we built are educational, not production-grade. A few things to keep in mind:

• The NPS API rate limit is 50 requests per second, which is generous, but don’t hammer it.
• The BLIP model was trained on general images, so its captions for specific park landmarks may be overly generic. You can fine-tune it, but that requires additional data.
• distilgpt2 is a small language model; its itinerary will be creative, not realistic. A larger model like Llama 3 would produce better results, but you’d need more memory and a proper hosting environment.
• The paper from the United Parks of America project shows what’s possible with significant engineering behind the scenes—your DIY version is a fun starting point, not a full replacement.

Conclusion

The Google Arts & Culture United Parks of America initiative, launched in August 2026, is a beautiful demonstration of how AI can bring the outdoors to any screen. But the same underlying concepts—natural language processing, vision-language models, and open data—are accessible to hobbyists and developers. With fewer than 150 lines of Python, you’ve now built an interactive journey through America’s national parks that lets you explore, describe, plan, and imagine.

This project is just the trailhead. Add features like weather forecasting, audio narration with a text-to-speech model, or even a chatbot trained on park FAQs. The key is to keep exploring—the same way you’d hike a new trail. AI will take you halfway; curiosity does the rest.