Houdini 18.5 Reference Stand-alone utilities


The Houdini license server. This program runs in the background managing Houdini licenses.

On this page

The Houdini installer registers this program with the operating system so it’s always running. It must be running for you to be able to run Houdini.

You should avoid editing the system files that register sesinetd to run at startup. Instead, you can put command line options you want to use in a sesinetd.options file. The location of the file depends on the operating system.


On macOS the installer registers the server as a daemon that launches when the system starts up (in /Library/LaunchDaemons/com.sidefx.sesinetd.plist). You can put command-line options in /Library/Preferences/sesinetd/sesinetd.options.


On Windows the installer registers the server as a service that launches when the system starts up.

You can put command-line options in a sesinetd.options file in C:\Windows\system32.


On Linux the installer creates an init.d script for the server. (This will still be picked up on systemd distributions by the system’s backward compatibility layer.) You can put command-line options in /usr/lib/sesi/sesinetd.options.

Command line options



Show this help.


Show the ini help.


Print the sesinetd version string.

Server log

-V/--min-logfile-level log level

Server log level.

  • 0 = no logging

  • 1 = fatal errors (Default)

  • 2 = errors

  • 3 = warnings

  • 4 = info

  • 5 = debug

-F/--min-console-level log level

Console log level. See the level values above.

-l/--logfile log file

Log file used for server logging information.

-z/--max-logfile-size log size

Maximum log file size.


Append the date to the server log.


Enable console output from the license server.


This option is not supported on Windows as all output is logged to the log file.


Log to the systems log file.

License log

-W/--license-log-level 0|1

License log level.

-u/--license-logfile log file

Log file used for licensing information.

-y/--max-license-log-size log size

Maximum license log file size.

Peak usage

-U/--usage-interval interval

Specify the usage reporting interval. This option must be specified to turn-on usage reporting. Interval values:

  • minute

  • 5-minute

  • 30-minute

  • hour

  • 4-hour

  • 12-hour

  • day


Include user information in the usage report. This is off by default.

-i/--peakusage-file file

Specify the usage report file location.

-Z/--peakusage-url url

The url to use when sending peak usage information.

-a/--peakusage-send-interval interval

The interval to send the peak usage interval information.


-p/--port port

Use a non-standard port for communication.

-n/--threads threads

Specify the number of threads to use. At least 4 threads must be used.

-m/--read-mask ip mask

The read mask used to validate permissions for clients.

-M/--write-mask ip mask

The write mask used to validate permissions for clients.


On non-Windows platforms do not run sesinetd in the background.


Place the license server in debug mode.


Enable license partitioning.



Enable ssl support for the server.

--ssl-cert-file file

SSL certificate file location

--ssl-priv-file file

SSL private file location

--ssl-ca-dir directory

CA directory for SSL enabled communication.

Options file

The location for this file is in the license directory for the specific platform with the name sesinetd.ini.


You can put options in /Library/Preferences/sesinetd/sesinetd.ini.


You can put options in a sesinetd.ini file in C:\Windows\system32.


You can put options in /usr/lib/sesi/sesinetd.ini.

Server log


Enable if logging should also be output through the console.


The minimum log level for the console. This is the same as setting -F on the command line.


Server log level. This is the same as setting -V on the command line.


The location the server log file should be. This is the same as setting -l on the command line.


When revolving the server log file append the date to the log file. This is handy for searching purposes. This is the same as setting -d on the command line.


Maximum server log size before revolving the log file. This is the same as setting -z on the command line.


Enable the license server to log to the system in addition to any other logging that has been setup.

License log


The log level for license information. (See the level values under "Peak usage" above.)


The path for the license log file. (See the level values under "Peak usage" above.)


The maximum log file size for the license log.


APIKey=host clientid client_secret

Specify an api key to be used for api key based requests. Login licensing through api keys are supported.


The custom port to run the server on. The default is 1715. This is the same as setting -p on the command line.


The number of threads to run the server with. The default is 6 threads. This value must be greater then or equal to 4. This is the same as setting -n on the command line.


The read mask for the server. This tells the server which IPs are allowed to perform read operations on the server. The default is *.*.*.* and is the same as setting -m on the command line.


The write mask for the server. This tells the server which IPs are allowed to perform modification operations on the server (i.e. install a license). The default is +.+.+.+ and is the same as setting -M on the command line.


Enable License Partitioning on the license server.


Enable SSL support on the server.


SSL support is currently a technical preview.


The certification file location.


The private ssl file location.


Enable debug mode. This enables extra verbosity and in some situations extra logging. This is extremely useful while debugging an issue with the license server.


New to 18.5 is epoll (linux), kqueue (OSX), and poll (Windows). If for some reason these new implementations are causing issues on the system this option will fallback to the old implementations. It is strongly suggested that you do not disable these implementations.

Peak usage


The url to be used when sending usage log information. This is mainly used for sending usage log information to sidefx.com for usage based pricing.


The interval at which to send the usage log information to the url endpoint.

Getting Started

License file

The keystrings themselves are written locally to the licenses file. Ensure that the operating system does not append a .doc or .txt to the licenses file. The file must be called licenses. If you are sent a copy of the licenses file for your machine from SideFX, you must restart the license server to have the new file read.


The location of the license file is /Library/Preferences/sesi/licenses


The location of the license file is C:\Windows\keys\licenses


The location of the license file is /usr/lib/sesi/licenses

License Types

  • Workstation* licenses are node locked licenses meaning they may be used on the machine itself and not floated across the network.

  • LAL (Local Access Licenses) serve locations up to 100km in distance.

  • GAL (Global Access Licenses) do not have location restrictions.


Apprentice and Indie users are only issued workstation (node locked) licenses.

Start/Stop the license server

You must have administrative rights (root, sudo) to be able to start/stop the license server.

If you initially installed Houdini using Apprentice Local Licensing, you will need to re-run the installer and choose Commercial Licensing. This will install the necessary license server tools.


You can start and stop HoudiniLicenseServer in Control Panel ▸ Administrative Tools ▸ Services.


Run the sesinetd startup script located in /etc/init.d

Use /etc/init.d/sesinetd {start|stop} to start or stop the server.


In a terminal, use sudo launchctl unload /Library/LaunchDaemons/com.sidefx.sesinetd.plist to stop the service.

Use sudo launchctl load /Library/LaunchDaemons/com.sidefx.sesinetd.plist to start the service.

When you restart the license server software on a centralized server machine, the remote clients will not lose their sessions for approximately 5 minutes of a failed heartbeat (or license check).

Peak usage logging

This is a great tool to monitor your peak license usage by product type which can be used for license planning. In a given interval (minute, hour, or day) the peak usage and optionally the user data can be monitored to a log file that can be exported to different representations which then can be used to plan for more license purchases as your needs grow.

Options for usage logging

Each of these options are license server (sesinetd) options.

-U is the only required option to turn the logging on and without this option specified usage logging is not turned on.

Available intervals:

  • minute

  • 5-minute

  • 30-minute

  • hour

  • 4-hour

  • 12-hour

  • day

Make sure to choose the interval correctly as the smaller the interval the longer the export will take.

This means that within the specified interval it will hold the required information (peak usage for that interval, who checked out a license within the interval, etc.) and at the end of the interval it will log to the log file all of the information accrued within the interval.


If a license has a peak usage of 0 (no one used the license in the interval) then nothing is logged for that license.


The interval start is rounded down to the previous interval.

For example, if you start with the minute specified as the interval at 11:00:52am the interval start will be 11:00:00am and the interval will end and log the information at 11:01:00am. Each interval after is based on the starting interval. Meaning that if the first interval is 11:00:00am the next will be 11:01:00am and so on.

The -i option specifies the location of the log file. The default location is in the license path with the name sesinetd_peak_usage.bin.


The default path is /Library/Preferences/sesi/sesinetd_peak_usage.bin


The default path is C:\Windows\keys\sesinetd_peak_usage.bin.


The default path is /usr/lib/sesi/sesinetd_peak_usage.bin.

The -G option logs who used the license within the time interval. By default users are not logged and only the peak usage for each license is logged to the file.

Peak Usage Exporter

The exporter is used to extract the peak usage information from the peak usage log file. The exporter can export this information into different formats (i.e. mysql) along with other options to tailor the information to your exact specifications.

The exporter is located in $HFS/python2.7libs/parsepeakuserlog.py.

Currently available exporter options are:


Do not display any progress information.


This is most helpful when you are bugging the exporter.


How the exporter should group the information. Currently the groups are hour, day, or month.


Display the peak usage information on a per license basis instead of per-product.


Where to write the exported information.


The format of the exported information. The available values are csv, mysql, or xlsx.


Specify that the exporter should include users when exporting the formation.


Type of csv dialect to use. Currently the only option is excel.


The start date of information the exporter should use while porting.


The end date of the information the exporter should use while exporting.


To use xlsx as an export type xlsxwriter must be installed prior to running the exporter.


For better timezone handling python module pytz can be used. For the most accurate handling of time tzlocal can also be installed. These modules must be installed prior to running the exporter.

Peak usage MySQL exported tables

Table sesinetd_user holds information about each user that used a license during the reporting period.


Data Type




Id of the user in the table.



username of the logged user.



machine of the logged user.

Usage by Product

Table sesinetd_product_usage holds information about the peak usage in a given interval by product.


Data Type




The product name for the usage entry.



The timestamp of the product usage.



The peak usage of the product for the timestamp.

Tablesesinetd_product_usage_users holds information about a user that used a product in the given interval.


Data Type




The id of the usage user.



The product name for the usage entry.



The timestamp the usage user was logged for.

Usage by License

Table sesinetd_license holds information about each license used during the reporting period.


Data Type




The id of the license logged.



The product type of the license.



The version of the license.



The total number of tokens for the license.



The expiry date of the license.



The ip mask for the license.

Table sesinetd_license_usage holds information about a licenses' peak usage in the given interval.


Data Type




The id of the license logged.



The time at which the usage interval was logged.



The peak usage for this license in the given interval.

Table sesinetd_license_usage_users holds information about a users using a given license in the interval.


Data Type




The user id of the usage user.



The license id the license the user was using.



The timestamp of the interval the usage had taken place in.

License Partitioning


This feature was added in License Server 18.5. A client Houdini License Server can still use this feature as long as the License Server is 18.5 or greater.

License partitioning is a great way to break up a studios set of licenses into different groups based on a wide range of conditions. This replaces the need to split up a studios licenses to multiple license servers and instead use the one server and break the studios licenses up virtually.

License partitioning is also a great way to control license access and restrict a studios critical licenses to the artists that need them, and block unintended license acquisitions from other artists.


The location of the partition file is in the platforms license directory with the name .partition.json. This file is intentionally hidden as eventually this file will be created and modified through a web browser and pushed to your server.


License partitioning must be enabled from sesined command line via --enable-partitioning or through the ini file enablePartitioning=true. Setting up the .partition.json file is not enough for the server to start using partitioning. This is meant as a safety mechanism in the event there is an old partition file that could prevent users from checking out licenses.

Partition File Example

    "user_groups": [
        "name": "Beta Testers",
        "if": "machine_name matches '^[a-zA-Z0-9_.]*.company.com$'"
        "name": "Studio",
        "if": "ip_address matches [10.1.1.*, 192.168.*.*, 127.0.0.*]"
        "name": "Studio Render Group",
        "if": "machine_name matches '^[a-zA-Z0-9_.]*.render.com$'"
        "name": "Experimental Users",
        "if": "username in ['user1', 'user2', 'user3']"
        "name": "PDG Team",
        "if": "username in ['user1', 'user2']"
    "license_partitions": [
        "if": "(product == 'Houdini Engine' or product == 'Houdini FX') and version >= 17.0",
        "user_group": "Studio",
        "quantity": 2
        "if": "(product == 'Renderer' || product == 'Karma-Renderer')",
        "user_group": "Studio Render Group",
        "quantity": 1
        "if": "product == 'Beta'",
        "user_group": "Beta Testers"
        "if": "product == 'Houdini-Master-Experimental'",
        "user_group": "Experimental Users"
        "if": "product == 'PilotPDG'",
        "user_group": "PDG Team"

The user_groups is used for placing requests into groupings. The license_partitions are used to split up the actual licenses and allow you to specify which groups can use which grouping of licenses. An easy way of thinking of it is to separate your groups of machines (user_groups) and then separate your licenses (license_partitions).

The user is able to request specific user groups to be considered when requesting licenses. The only requirement is that the user group is defined in the partition file. For more information see hserver.

Supported Types

Partitioning supports basic types in a python style format.




10.51. Decimals are of the standard decimal format. In fact all numbers are converted to decimals.


"Hello World!" or 'SideFX'. Strings are of the standard string format.


[ type, type, ... ] ex. [ "Hello World", "Sidefx", "license" ] or [ 1.0, 1.2, 1.3 ]. The type must be the same throughout the array. Currently supported array types are string, decimal, and ip masks.

IP Mask

10.1.1.*, 192.168.+.*. The mask is the standard mask format found in the servers options file or license string. The mask can also be combined with an array to match against a list of masks.




and &&

Standard and operators.

or ||

Standard or operators.

== !=

Standard comparison operators.


Check if an item is found inside another object. This is typically used to check if an object is inside of an array.


This allows for comparison of two objects that don’t need to be exactly equal. This is commonly used for regex comparisons.

> < >= <=

Standard comparison operators.


Standard python style line comments.

( )

Standard bracket group operators.

Reserved variables

There are several reserved variable names that are used to pull in information from the object we are comparing against. In the case of licenses the version info is available through the variable version.

Variable Name



This is the licenses product name (i.e. Houdini-Master). The values used are the internal product names and not the product display names. Display names are subject to change and do not support backwards compatibility. For these reasons we use the internal name (i.e. Houdini-Master).


This is the platform the license is tied to.


The license id from the license string.


The version of the license. This is represented in decimal form as 18.5. All regular decimal comparison operations are supported (i.e. <=, ==, !=).


The ip mask of the license.


The ip address of the client the request came from. This is in IPv4 format (i.e.


This is the username of the client the request came from. If the client computer name is user@machine the username would be user.


This is the username of the client the request came from. If the client computer name is user@machine the machine name would be machine.

Log File

The log file is where the server will output information about its health, connection information, and other useful information.

Each log entry is of the form YYYY-MM-DD HH:MM::SS: SYSTEM - MESSAGE.

  • HTTP Client are messages coming from curl or messages relating to connection/client systems.


If verbose curl is turned on then the output will be logged under this system. Please see curls webpage for a more detailed explanation of their log entries.

  • Sqlite are messages coming from sqlite itself. Sqlite is mostly used for cookie storing or any other persisten storage needs.

  • Network Manager is the most common message in the log file. This message typically will come from the server itself. In most cases its used to log information about an incoming connection or response to a request.

  • Stats Manager are messages that come from the statistics manager. This is typically messages regarding statistics about the running server (i.e. max process time of a request).

  • Error with api response are messages that are a result of an error with an API response.

  • Access Token are messages that come from API keys. Typically a message about an invalid API token or unable to update the API token.

  • Service are messages that come from the service itself.

  • Application are messages that are related to the application. This error message is extremely uncommon.

The log entry Starting release server v18.5.296 at displays if the server is a development server or a release server, the server version, the ip address and the port the server is running on. This can come in handy if you need to know the server version you are running on. This also makes it easier to see what version produced what inside a log file that might have multiple server versions in it.

The log entry Using fast fd set configuration... is just an entry to signify what mechanism the server is using for detecting data available on a socket. If the server is using fast fd set configuration then on Linux the server is using epoll and OSX its using kqueue (Windows currently does not support such a configuration). If its using the default fd set configuration then its using poll() on all platforms.

HTTP Response Logs Entries


Example entry: 2020-06-17 19:48:02: Network Manager - "POST /api HTTP/1.1" 200 Ok cmd_ping 0.0022450001s


  • ROUTE: /api, /login, /

  • VERSION: 1.1, 1.0, 0.9

  • CODE: 200, 400, 404

  • CODE_MESSAGE: Ok, Bad Request, Not Found

  • COMMAND: cmd_ping

  • RESPONSE_TIME: 0.001s

Statistics Manager Log Entries

The process time entry displays the average process time and maximum process time of all requests over the lifetime of the running server. This is measured from the time the request starts processing to the time the process replies.

Example entry: 2020-06-17 19:46:51: Stats Manager - Process Time: avg 0.010118s, max 0.020763s

The queue wait time displays the average and maximum time all requests wait in the queue to be processed by a worker thread. These numbers are from the entire lifetime of the server.

Example entry: 2020-06-17 19:46:51: Stats Manager - Queue Wait Time: avg 3.6666667e-05s, max 6.5e-05s

The queue size displays the current queue size and the maximum size the queue ever got to. These numbers are from the entire lifetime of the server.

Example entry: 2020-06-17 19:46:51: Stats Manager - Queue Size: current 0, max 1

The connection count log entry displays the current number of connections the server is holding onto. For instance, if the server is reusing connections then this count will be representative of these reused connections.

Example entry: 2020-06-17 19:46:51: Stats Manager - Connection Count: 0

Public API


An 18.5 or greater server is required.

Some API functions are exposed to allow for calling outside of the licensing tools. This provides a wide range of extended abilities such as monitoring license usage using a language such as python. The API syntax is identical to hou.webServer.apiFunction(). All API requests are done through POST and on the route /api. A successful response will always be in JSON format.

The format of the request is json=[<function name>, [<function parameters>], {<kwargs function parameters>}].

Key list and server information

The API function name for grabbing key list is called cmd_ls. Using direct requests to the server is the recommended approach moving forward as this will be more resilient to changes, faster, and easier to transform the data into other formats.

A typical http request would look something like this:

POST /api HTTP/1.1
Connection: keep-alive
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.22.0
Content-Type: application/x-www-urlencoded
Content-Length: 23

json=["cmd_ls", [], {}]

To adjust the response to your needs adjust the kwargs of the function with the following parameters:

short_form (boolean)

Short form the response for both licenses and server information.

expires (int)

The number of days from now that the license expires.

server_data (boolean)

Include the server data in the response.

show_all (boolean)

Show all licenses found in the license file. Expired and invalid licenses are included.

show_version (boolean)

Include the server version in the response.

only_version (boolean)

Only include the server version in the response.

show_server (boolean)

Include all server keys known to the server.

show_users (boolean)

Include user information with each license.

show_licenses (boolean)

Include license information with the response.

Example request:

json=["cmd_ls", [], {"show_licenses": True, "show_server": False, "expires": 15}]
import requests
import json

response = requests.post("", data={"json": json.dumps(["cmd_ls", (), {"show_licenses": True}])})
data = response.json()
licenses = data["licenses"]
for license in licenses:
    print("License: {} {}/{} {}".format(license["product"], license["available"], license["total_tokens"], license["version"]))

With sample output:

License: Houdini Apprentice 40/50 18.0
License: Houdini FX 74/100 18.0
License: Houdini Engine 20/200 18.0

A use case for direct requests to the server for key list information is to log license usage overtime. This allows your studio to get realtime insights into the studios license needs and the servers health overtime. An example of periodically requesting server information and logging it into a simple mysql database for external application like grafana to display is shown below.

Periodically request information from a running sesinetd and dump that
information into a mysql database for viewing.

from __future__ import print_function
import sys
import requests
import argparse
import threading
import json
import mysql.connector
from datetime import datetime
import time

class Runner(object):
    def __init__(self):
        self.args = None

    def add_options(self, parser):
        parser.add_argument("--server", help="Server to request information from", default="localhost")
        parser.add_argument("--port", help="Server port number", default=1715)
        parser.add_argument("--interval", help="Interval to send requests.", default = 30)

    def server_url(self, route):
        return "http://{}:{}{}".format(self.args.server, self.args.port, route)

    def execute(self):
        # Make sure the entire request has the same timestamp
        timestamp = time.time()
        response = requests.post(self.server_url("/api"),
                             data={"json": json.dumps(["cmd_ls", (), {}])}

        db = mysql.connector.connect(
            user=<sql user>,
            password=<sql password>)

        cursor = db.cursor()

        sql_database = "CREATE DATABASE IF NOT EXISTS sesinetd"
        cursor.execute("USE sesinetd")

        sql_table = "CREATE TABLE IF NOT EXISTS usage ( " \
                "timestamp INT," \
                "product VARCHAR(25) NOT NULL," \
                "available SMALLINT," \
                "total_tokens SMALLINT," \
                "version VARCHAR(10) NOT NULL," \
                "tokens_used SMALLINT);"

        sql_table = "CREATE TABLE IF NOT EXISTS response_times ( " \
                "timestamp INT," \
                "response_time FLOAT);"

        sql = "INSERT INTO usage (product, available, total_tokens, version, timestamp, tokens_used) VALUES (%s, %s, %s, %s, %s, %s);"
        data = response.json()
        licenses = data["licenses"]
        for license in licenses:
            product = license["product"]
            available = license["available"]
            total_tokens = license["total_tokens"]
            version = license["version"]
            cursor.execute(sql, (product, available, total_tokens, version, timestamp, (total_tokens - available)))

        sql = "INSERT INTO response_times (timestamp, response_time) VALUES (%s, %s);"
        cursor.execute(sql, (timestamp, response.elapsed.total_seconds()))


    def run(self):
        parser = argparse.ArgumentParser(
            description="Periodically request information from a running sesinetd"
                    " which is dumped into mysql.")
        self.args = parser.parse_args()


        interval = self.args.interval
        ticker = threading.Event()
        while not ticker.wait(interval):

if __name__ == "__main__":

Stand-alone utilities

  • abcconvert

    Convert between Alembic formats.

  • abcecho

    Print information about an Alembic file.

  • abcinfo

    Print information about an Alembic file.

  • chchan

    Copies channel collection to/from action channel format.

  • chcp

    Copies channel collection file to another format.

  • chinfo

    Prints information about a channel collection file.

  • claudio

    Copies CHOP data (clip) to/from audio formats.

  • clchan

    Copies CHOP data (clip) to/from action channel format.

  • clchn

    Copies CHOP data (clip) to/from channel collection format.

  • clcp

    Copies CHOP data (clip) to another format.

  • clinfo

    Prints information about a CHOP data (clip) file.

  • dsmconvert

  • dsmmerge

  • dsparse

    Parses and displays dialog scripts.

  • gabc

    Convert between Alembic and Houdini geometry.

  • gconvert

    Convert between Houdini polygon formats.

  • gdxf

    Converts DXF polygons to/from Houdini format.

  • geodiff

    Display Geometry Differences.

  • geps

    Converts EPS files to Houdini polygon format.

  • giges

  • ginfo

    Prints polygon file statistics.

  • glightwave

    Converts LightWave files to/from Houdini format.

  • gpdb

    Converts .pdb files to/from Houdini format.

  • gplay

    Geometry viewer.

  • gply

    Converts .ply files to/from Houdini format.

  • gptex

    Makes a ptexture image file from a geometry file.

  • greduce

    Reduces polygons in a file.

  • gwavefront

    Converts .obj files to/from Houdini format.

  • hbrickmap

    Converts an i3d file or volume primitive geo/bgeo file into a Pixar brickmap file.

  • hcollapse

    Collapses a directory structure.

  • hcpio

  • hexpand

    Expands hip files into a directory structure.

  • hkey / License Administrator

    Opens a graphical user interface for viewing and managing licenses and license server options.

  • hrender

  • hsc

  • hscript

    Command line HScript interpreter.

  • hserver

    Houdini communicates through this proxy server to the sesinetd licensing daemon.

  • husk

    Command line utility for rendering a USD file using Karma or some other Hydra client.

  • i3dconvert

  • iautocrop

    Crops images based on pixel values.

  • icineon

    Convert images from 10-bit Cineon format to an 8 bit format.

  • icomposite

  • iconvert

    Converts image formats.

  • icp

    Isolate a region of an image in a new image.

  • idenoise

    Removes noise from an image file.

  • idiff

    Display Image Differences.

  • iflip - Flip Image

  • iinfo

    Outputs information about an image.

  • ilut

    Generates a lookup table (LUT) from standard channel formats or another LUT.

  • ilutcomp

    Generates a single lookup table (LUT) from from two LUTs.

  • ilutinfo

    Prints information about a lookup table (LUT) file.

  • imaketx

    Creates mipmapped .exr or .rat textures from image files.

  • imdisplay

    Sends an image to an mdisplay window.

  • iprint

    Prints the RGBA values for an image as text.

  • iquantize

    Reduces the number of colors in an image.

  • isixpack

    Generates an environment/reflection map from six images representing the six sides of a cube, or a cross image.

  • itilestitch

    Assemble a series of image files with crop windows into a single image.

  • izg

    Converts Z-depth images to 8-bit grayscale images.

  • Launcher

    The Houdini Launcher downloads, installs, upgrades, and uninstall Houdini and its components.

  • mcacclaim

    Converts an Acclaim motion file to a Houdini script and channel file(s).

  • mcbiovision

    Converts a BioVision motion file to a Houdini script and channel file(s).

  • mcmotanal

    Converts a Motion Analysis TRC motion file to a Houdini script and channel file(s).

  • mcp

    Convert an image sequence to a movie file.

  • minfo

    Prints information about movie files.

  • mqserver

    Message Queue Server for PDG/TOPs

  • sesictrl

    Sets Houdini license server options from the command line.

  • sesinetd

    The Houdini license server. This program runs in the background managing Houdini licenses.

  • siminfo

    Prints simulation cache file statistics.

  • spiff

    Display Text Differences.

  • spy

    Shell utility for navigating the UNIX filesystem.

  • vexcache

    Query or modify the VEX compile cache.

  • vexexec

    Execute a cvex shader.