Struct rerun::commands::entrypoint::Args

struct Args {

    command: Option<Command>,
    bind: String,
    drop_at_latency: Option<String>,
    memory_limit: String,
    server_memory_limit: String,
    persist_state: bool,
    port: u16,
    profile: bool,
    save: Option<String>,
    screenshot_to: Option<PathBuf>,
    serve: bool,
    serve_web: bool,
    expect_data_soon: bool,
    threads: i32,
    url_or_paths: Vec<String>,
    version: bool,
    web_viewer: bool,
    web_viewer_port: WebViewerServerPort,
    hide_welcome_screen: bool,
    window_size: Option<String>,
    ws_server_port: RerunServerPort,
    renderer: Option<String>,
    video_decoder: Option<String>,
    test_receive: bool,
}

Fields

command: Option<Command>

bind: String

What bind address IP to use.

drop_at_latency: Option<String>

Set a maximum input latency, e.g. “200ms” or “10s”.

If we go over this, we start dropping packets.

The default is no limit, which means Rerun might eat more and more memory and have longer and longer latency, if you are logging data faster than Rerun can index it.

memory_limit: String

server_memory_limit: String

persist_state: bool

port: u16

What TCP port do we listen to (for SDKs to connect to)?

profile: bool

Start with the puffin profiler running.

save: Option<String>

Stream incoming log events to an .rrd file at the given path.

screenshot_to: Option<PathBuf>

Take a screenshot of the app and quit. We use this to generate screenshots of our examples. Useful together with --window-size.

serve: bool

Deprecated: use --serve-web instead.

serve_web: bool

Serve the recordings over WebSocket to one or more Rerun Viewers.

This will also host a web-viewer over HTTP that can connect to the WebSocket address, but you can also connect with the native binary.

rerun --serve-web will act like a proxy, listening for incoming TCP connection from logging SDKs, and forwarding it to Rerun viewers.

expect_data_soon: bool

This is a hint that we expect a recording to stream in very soon.

This is set by the spawn() method in our logging SDK.

The viewer will respond by fading in the welcome screen, instead of showing it directly. This ensures that it won’t blink for a few frames before switching to the recording.

threads: i32

The number of compute threads to use.

If zero, the same number of threads as the number of cores will be used. If negative, will use that much fewer threads than cores.

Rerun will still use some additional threads for I/O.

url_or_paths: Vec<String>

version: bool

Print version and quit

web_viewer: bool

Start the viewer in the browser (instead of locally).

Requires Rerun to have been compiled with the web_viewer feature.

This implies --serve-web.

web_viewer_port: WebViewerServerPort

What port do we listen to for hosting the web viewer over HTTP. A port of 0 will pick a random port.

hide_welcome_screen: bool

Hide the normal Rerun welcome screen.

window_size: Option<String>

Set the screen resolution (in logical points), e.g. “1920x1080”. Useful together with --screenshot-to.

ws_server_port: RerunServerPort

What port do we listen to for incoming websocket connections from the viewer A port of 0 will pick a random port.

renderer: Option<String>

Override the default graphics backend and for a specific one instead.

When using --web-viewer this should be one of: webgpu, webgl.

When starting a native viewer instead this should be one of:

• vulkan (Linux & Windows only)

• gl (Linux & Windows only)

• metal (macOS only)

video_decoder: Option<String>

Overwrites hardware acceleration option for video decoding.

By default uses the last provided setting, which is auto if never configured.

Depending on the decoder backend, these settings are merely hints and may be ignored. However, they can be useful in some situations to work around issues.

Possible values:

• auto May use hardware acceleration if available and compatible with the codec.

• prefer_software Should use a software decoder even if hardware acceleration is available. If no software decoder is present, this may cause decoding to fail.

• prefer_hardware Should use a hardware decoder. If no hardware decoder is present, this may cause decoding to fail.

test_receive: bool

Ingest data and then quit once the goodbye message has been received.

Used for testing together with RERUN_PANIC_ON_WARN=1.

Fails if no messages are received, or if no messages are received within a dozen or so seconds.

Implementations

impl Args

fn generate_markdown_manual() -> String

Trait Implementations

impl Args for Args

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl CommandFactory for Args

fn command<'b>() -> Command

Build a [Command] that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a [Command] that can update self.

impl Debug for Args

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Args

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Args

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::exit] on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, [exit][Error::exit] on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, [exit][Error::exit] on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.