Product Changelog

​

Machine Type in Runner Output

• fal runners list and fal app runners <app> now display the machine type for each runner (e.g. GPU-A100, GPU-H100)
• JSON output (--output json) also includes the machine_type field for each runner

​

Runner FAILURE_DELAY Status

• Runners that fail during setup() now show a FAILURE_DELAY status, making it easier to identify runners that are in a cooldown period before retrying initialization
• You can filter runners by this state using fal runners list --state failure_delay
• See Understanding Runners for details

​

Interactive Log Histogram

• The logs page now features an interactive histogram that visualizes log volume over time, broken down by severity level
• Click and drag to select a time range on the histogram to zoom into that window and filter your logs instantly
• Zoom in and out to explore log patterns at different time granularities
• Color-coded bars show the distribution of stderr, error, warning, info, and trace logs at a glance

​

Jump to Context

• When viewing a specific log entry, use the new Jump to Context button to instantly scroll to surrounding log lines
• Quickly see what happened before and after any log entry without manually searching through timestamps
• Especially useful when navigating to a log from a shared link or alert

​

Switch Log Timezones Between UTC and Local

• You can now toggle between UTC and your local timezone directly from the datepicker in the logs page
• All log timestamps, filters, and the histogram update instantly when switching timezones

​

Serverless App Cards with Error Rates and Graphs

• The app listing page now displays rich cards for each serverless app with at-a-glance performance metrics
• Error rate indicators show the health of each app directly on the card
• Inline sparkline graphs visualize request volume and error trends over time
• Quickly identify apps that need attention without clicking into each one individually

​

Share Logs with Your Team

• You can now click on any log entry and share the link directly with the rest of your team
• Shared log links preserve the full context of the log, making it easy to collaborate on debugging and troubleshooting

​

Runner Side Sheet

• Click into any runner on the Runners page to open a detailed side sheet with telemetry, logs, and the ability to connect to the runner
• Makes it much easier to debug and observe your runners without leaving the page

​

--auth flag for fal run

fal run path/to/myapp.py::MyApp --auth private

• public — no authentication required, app owner pays
• private — only you or your team can access

​

Full-Screen Logs

• The logs page now opens in a full-screen view, giving you significantly more vertical and horizontal space to work with
• See more log lines at once and reduce scrolling when debugging complex issues

​

FalBaseModel for better input/output definitions

• Hidden fields - Use Hidden(Field(...)) to mark parameters as API-only, hiding them from the playground UI while keeping them accessible via API
• Field ordering - Control the order of fields in your API schema with FIELD_ORDERS
• Media field helpers - Use ImageField, AudioField, VideoField, and FileField for better playground rendering

from fal.toolkit import FalBaseModel, Field, Hidden, ImageField

class TextToImageInput(FalBaseModel):
    FIELD_ORDERS = ["prompt", "negative_prompt", "image_size"]

    prompt: str = Field(description="Text description of the image")
    negative_prompt: str = Field(default="", description="What to avoid")
    image_size: str = Field(default="1024x1024")

    # Hidden from playground but accessible via API
    debug_mode: bool = Hidden(Field(default=False))
    internal_seed: int = Hidden(Field(default=-1))

class ImageToImageInput(FalBaseModel):
    image_url: str = ImageField(description="Input image")
    strength: float = Field(default=0.8)

​

Switch environments from app pages

• Environment dropdown - Click the environment badge on any app page to see all environments where the app is deployed
• One-click switching - Select an environment to navigate to the same app in that environment
• Quick access - View environment secrets or create new environments directly from the dropdown

​

Track when runners are idle and waiting for work

• IDLE state visibility - see when runners finish processing and are waiting for new work
• Better resource monitoring - distinguish between actively processing requests and waiting states
• Improved observability - track idle time to optimize scaling and resource allocation

​

Control queue wait time with start_timeout

​

Environments for isolated deployments

• Create isolated environments for development, staging, and production
• Environment-scoped secrets - use different API keys and credentials per environment
• Deploy to specific environments using the --env flag

# Create a staging environment
fal environments create staging

# Deploy to staging
fal deploy my_app.py --env staging

# Set environment-specific secrets
fal secrets set API_KEY=staging-key --env staging

​

Handle graceful shutdown with handle_exit() and teardown()

• handle_exit() - Called when the runner is requested to terminate to signal handlers to stop early.
• teardown() - Called when the runner is shutting down to clean up resources.

​

Include local files in container builds with COPY and ADD

• Automatic file parsing - fal parses your Dockerfile to find COPY/ADD commands and collects referenced files
• Hash-based deduplication - Files are uploaded to fal’s storage with content-addressable deduplication (files from app_files are reused automatically)
• .dockerignore support - Create a .dockerignore file or use add_dockerignore() to exclude files
• Multi-stage build support - COPY --from=... commands are correctly handled (only local files are collected)
• Smart rebuilds - Changes to your fal.App file don’t trigger rebuilds (it’s pickled separately); only changes to COPY/ADD referenced files trigger rebuilds

dockerfile_str = """
FROM python:3.11
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY src/ ./src/
"""

class MyApp(fal.App):
    image = ContainerImage.from_dockerfile_str(dockerfile_str)

​

Skip retries for specific conditions

class MyApp(fal.App):
    skip_retry_conditions=["timeout"]  # This app won't retry on timeout
    ...

​

Graceful shutdown of fal apps

​

Add a health check endpoint to your application

• Health check endpoint - Pass the health_check parameter to the @fal.endpoint() decorator to configure an endpoint as your health check
• Periodic checks and recovery - fal periodically (every 15 seconds) calls this endpoint and replace unhealthy runners if it fails for a few consecutive calls

class MyApp(fal.App):
    @fal.endpoint("/health", health_check=fal.HealthCheck(failure_threshold=3))
    def health(self) -> HealthResponse:
        if not self.connection.is_alive():
            raise RuntimeError("Lost connection to the external service")
        return HealthResponse(status="ok")

​

Disable environment build cache

​

Scale your application with the new scaling delay feature

• Scaling delay - the amount of seconds the system will wait for a request to be picked up by a runner before triggering a scale up of a runner

class MyApp(fal.App):
    scaling_delay = 30
    # ...

​

Reduce cold start times with shared compiled PyTorch caches

• Load pre-compiled CUDA kernels in ~2 seconds instead of recompiling for 20-30 seconds on each worker
• GPU-specific caching automatically organized by GPU type (H100, H200, A100)
• Two usage patterns: Manual control with load_inductor_cache() / sync_inductor_cache() or automatic with synchronized_inductor_cache() context manager
• Persistent shared storage at /data/inductor-caches/<GPU_TYPE>/<cache_key>.zip
• First worker compiles and shares, subsequent workers load instantly

from fal.toolkit import synchronized_inductor_cache

with synchronized_inductor_cache("mymodel/v1"):
    self.model = torch.compile(self.model)
    self.warmup()  # Compilation happens once, synced automatically

​

Get Slack notifications for serverless app failures

• Connect your workspace with one-click OAuth installation
• Choose notification channel from a dropdown of your Slack channels
• Instant alerts for:
  • App startup failures and timeouts
  • Critical platform issues
  • Real-time error notifications
• Team visibility - everyone in the channel sees important updates
• Configure at https://fal.ai/dashboard/notifications/settings

​

Stop and kill runners directly from the dashboard

• Graceful shutdown or force kill runners with a single click
• Access at https://fal.ai/dashboard/apps/{username}/{appname}/runners

​

Stream platform logs to your own endpoint with drains

• Automatic log forwarding from apps, runners, and file operations in NDJSON format
• Works with Datadog, Splunk, Elasticsearch, or any HTTP endpoint
• Configure at https://fal.ai/dashboard/drains

​

Upload larger files with improved timeout handling

• Extended timeout to 10 minutes for fal files upload and fal files upload-url
• Upload multi-GB files without timeout errors
• See fal files docs

​

Restart all runners without redeploying

• Restart all runners for an app without creating a new deployment
• Graceful by default (runners finish current requests) or use --force for immediate restart
• Pick up new secrets, environment variables, or clear memory issues
• See fal apps rollout docs

​

Stop specific runners without affecting others

• Stop specific runners without affecting others, useful for targeted maintenance
• See fal runners docs

​

Debug production runners with interactive shell access

• SSH-like access to inspect files, environment variables, and dependencies
• Debug production issues without redeploying
• See fal runners shell docs

​

See everything happening in your app with the events timeline

• Unified timeline of runner events, deployments, and config changes
• Access at https://fal.ai/dashboard/apps/{username}/{appname}/events

​

Get from zero to deployed in minutes with in-app onboarding

• Step-by-step walkthrough from installation to deployment with copy-paste examples
• Access at https://fal.ai/dashboard/serverless-get-started

​

Delete files from fal storage

• Recursive deletion: fal files rm path/to/file-or-directory
• See fal files docs

​

Platform APIs v1 officially released

• Model discovery - search and metadata retrieval for 600+ models
• Pricing and cost estimation - real-time pricing information
• Usage tracking - detailed line items with quantities and prices
• Analytics - request counts, error rates, and latency percentiles
• Available at https://api.fal.ai/v1 - see docs

​

Get notified when you hit concurrent requests limits

• Email and dashboard notifications with smart throttling (immediate, 1h, 1d, weekly)
• Limit value included in 429 responses for programmatic handling

​

Debug errors faster with the new errors page

• Server vs client error rates with 4xx/5xx breakdown and sparklines
• Error timeline with status code distribution and endpoint-level breakdown
• Access at https://fal.ai/dashboard/apps/{username}/{appname}/errors

​

Stop or kill individual runners from the command line

• fal runners stop - gracefully stop a runner, allowing in-flight requests to complete
• fal runners kill - immediately terminate a runner without waiting
• See fal runners docs

​

See exactly how long runners spend starting up

• Pending uptime metrics show how long runners wait before becoming active
• Track PENDING, DOCKER_PULL, and SETUP state durations separately

​

Connect fal docs to Cursor with MCP

• Complete documentation in your IDE with AI-powered suggestions
• Simple setup: add fal MCP server to your mcp.json - see guide

​

Personalized dashboard with creator and developer views

• Creator view - gallery-focused with favorite models and visual generation history
• Developer view - metrics-driven with usage stats, error tracking, and API analytics
• Quick stats showing credits, requests, and errors with sparklines

​

Add custom headers to your API requests

• Add custom headers for analytics, authentication, or middleware integration
• Works with all client libraries

​

Multi-GPU inference and training with fal.distributed

• Data parallelism - generate multiple outputs simultaneously (e.g., 4 images on 4 GPUs)
• Model parallelism - split large models across GPUs for faster generation
• Distributed training - synchronized gradient updates with DDP
• Supports 2, 4, or 8 GPU configurations on H100s and A100s
• See distributed docs

​

Dedicated pages for Analytics, Runners, Logs, and Versions

• New Analytics page - runner-focused metrics with date range filtering
• New Runners page - app-scoped runner view with enhanced filters
• New Logs page - dedicated log viewer for debugging
• New Versions page - manage and view app revisions
• Enhanced Overview - endpoint stats and performance metrics at a glance

​

Compare models side-by-side in the new Sandbox

• Run multiple models simultaneously with the same prompt
• Available at https://fal.ai/sandbox

​

Manage deployments from Python without async/await

• Manage apps, runners, and deployments programmatically without async/await
• Same API as CLI: client.apps.*, client.runners.*, client.deploy()
• See Python client docs

​

Bring your own container to any deployment

• Use ContainerImage.from_dockerfile_str() or ContainerImage.from_dockerfile()
• Install any dependencies, tools, or system packages you need
• See custom containers guide

​

Dynamic auto-scaling with percentage-based buffers

• Configure buffer as a percentage of current concurrency for dynamic scaling
• See scaling docs

​

Runner logs with streaming and filtering

• Stream logs in real-time with fal runners logs --follow
• Filter by time range with --since and --until
• Search logs with --search parameter
• Scrollable and searchable in the dashboard with SSE-powered updates
• See fal runners logs docs

​

Include local files in your deployments automatically

• Specify files with relative or absolute paths to include at runtime
• Works with fal run and fal deploy
• See app files docs

​

Find what you need faster with reorganized navigation

• Generate group: Sandbox, Model Gallery
• Serverless group: Apps, Logs, Files, Runners
• Manage group: Usage, Billing, API Keys, Webhooks, Team Members

​

Know exactly which version each runner is running

• Revision ID displayed on runners to track which version is running
• State renamed: “DEAD” → “TERMINATED” for clarity

​

Filter logs with custom labels and powerful queries

• EXACT or CONTAINS matching for label values
• Multiple conditions with OR logic (e.g., status IN ["error", "warning"])
• Available in dashboard and API
• Examples: error_type = "ValidationError", endpoint CONTAINS "/api/v2/"

​

See what runners are doing during startup

• fal runners list now shows PENDING, DOCKER_PULL, and SETUP states
• Understand deployment progress in real-time

​

View all app endpoints and config at a glance

• Endpoints, configuration, and status all in one place

​

Monitor and clear your request queue from the CLI

• fal queue size app_name - check queue size for an app
• fal queue flush app_name - flush all pending requests
• See fal queue docs

​

View runner history with time-based filtering

• fal runners list --since "1h" - view runners from the last hour (max 24h)
• fal runners list --state dead - filter by state (running, pending, setup, dead)
• Helpful for debugging failed deployments and understanding runner lifecycle
• See fal runners list docs

​

Reorganize files in fal storage without re-uploading

• Rename or move files in fal storage: fal files mv source destination
• See fal files docs

​

See all your endpoint URLs immediately when testing

• CLI prints playground, synchronous, and asynchronous routes for fal run