smartRender lets you reduce your rendering times and makes rendering dramatically faster compared to the standard rendering process. It uses all your hardware resources efficiently to speed up the processing.
smartRender supports the ability to speed up preview renderings. While your comp is work in progress where you want to get instant feedback you can use incremental renderings and down scalings to get get your previews in seconds instead of waiting for some minutes.
smartRender lets you view a detailed log for the job which lets you also detect rendering errors. All job logs can be exported as text files.
smartRender works out of the box producing fast renderings but if you have some programing experience you can even edit, change and customize smartRender's processing commands so you can fully customize it to your needs.
The following shows some direct 1:1 real time render comparisons between smartRender and NUKE's default rendering method. We tested different nuke scripts of different scale with different machines and different operating systems. Each test is a real time recording of the exact same nukescript on the same machine. In our tests rendering with smartRender was always faster, sometimes even incredibly 4 times faster. As these comparisons are quite long feel free to simply skip through them and have a look at the comparison chart at the end of each video. The brave ones watch the whole video in one go :-D
Nuke script size: large
Machine: MacPro 6,1 3GHz 8-Core Intel Xeon E5 32GB 1866 MHz DDR3
OS: MacOSX 10.9.5
Nuke version: Nuke9.0v5
Node count: 811 nodes
Description: A large nuke script containing a lot of 2D and 3D nodes.
Standard rendering: 21:40
smartRender used only 54,5% of the standard rendering time.
Nuke script size: small
Machine: MacBook Pro 11,3 2,5GHz i7 16GB 1600 MHz DDR3
OS: Ubuntu 14.04.4 (ubuntu trusty tahr)
Nuke version: Nuke10.0v1
Node count: 68 nodes
Description: A small size nuke script containing full cg compositing, inclusive vector blurs with high motion vector samples and a pretty render intensive TVI scale node to upscale the whole image in the end.
Standard rendering: 38:41
smartRender used only 22,9% of the standard rendering time.
Nuke script size: small
Machine: MacBook Pro 11,3 2,5GHz i7 16GB 1600 MHz DDR3
OS: MacOSX 10.10
Nuke version: Nuke8.0v1
Node count: 4 nodes
Description: A simple nuke script using motion blur with a high sample rate and a median with a high size.
Standard rendering: 08:04
smartRender used only 64% of the standard rendering time.
Nuke script size: middle
Machine: HP Z800 2,67GHz 24 Core 64GB 1600 MHz DDR3
Nuke version: Nuke8.0v7
Node count: 383 nodes
Description: A mid size nuke script including cg compositing into real shot footage.
Standard rendering: 24:57
smartRender used only 31.8% of the standard rendering time.
Nuke script size: middle
Machine: MacPro 6,1 3GHz 8-Core Intel Xeon E5 32GB 1866 MHz DDR3
OS: MacOSX 10.9.5
Nuke version: Nuke9.0v5
Node count: 112 nodes
Description: A mid size nuke script. This time we did a background rendering method for the standard rendering.
Standard rendering: 09:37
smartRender used only 24,9% of the standard rendering time.
Nuke script size: middle
Machine: MacPro 6,1 3GHz 8-Core Intel Xeon E5 32GB 1866 MHz DDR3
OS: MacOSX 10.9.5
Nuke version: NukeStudio9.0v8
Node count: 362 nodes
Description: A mid size nuke script combining CG elements with real shot footage. This time we did a timeline rendering method in NukeStudio with 16 render threads for the standard rendering and a 16 threads render using smartRender.
Standard rendering: 08:34
smartRender used only 67,7% of the standard rendering time.
Like any other cragl product smartRender can be installed with cragl connect directly inside NUKE.
Open connect and drag smartRender to the right to reveal more information. Just click on "buy" and you will be located to the web page where you can purchase smartRender. After purchasing you will receive a mail including an instal code. Now simply click on install, enter your received instal code and smartRender will be installed automatically on your machine.
After the installation is finished you will now find the new sub menu "smartRender" inside your cragl menu. It contains three commands: "render", "settings" and "about".
render: opens the smartRender main window to set up your renderings. The shortcut is cmd + R (mac) and ctrl+r (linux + windows).
settings: opens the smartRender settings window
about: opens the smartRender about window
To open the smartRender window navigate to NUKE's menubar and choose "cragl->smartRender->render". The shortcut is cmd + R (mac) and ctrl+r (linux + windows).
The smartRender main window contains three sections: The presets section, The output section and the The log section.
To navigate between the different sections you can use the tabs at the top left to enter the presets- and the output section (image below 1) and 2)) and the job history button at the top right to enter the log section (image below 3)). You can also press the "L"-key to toggle the job history. The state of the currently selected tab from the left will be saved even after closing the smartRender window, exiting nuke and shutting down your computer. 1) click to change to the presets section
2) click to change to the output section
3) click to change to the job history section. Can also be toggled with using the "L"-key.
If you click one of the tabs/buttons the corresponding section will appear:
1) The presets section. Further information about the presets section can be found at 4) The presets section
2) The output section. Further information about the out section can be found at 5) The output section
3) The job history section. Further information about the presets section can be found at 6) The job history section
The presets section lets you save your currently selected render settings. This can become useful when you often need to switch between different render settings like for instance previews and final outputs.
For more information about saving a preset please refer to 4.1) Saving a preset.
The preset section contains 8 elements:
1) presets list: all your saved preses are stored in this list to quickly switch between different render presets
2) preset details: displays the details of the currently selected preset
3) add preset button: click to add a new preset
4) load preset button: click to load the currently selected preset
5) remove preset button: click to remove the currently selected preset
6) render button: click to render the checked write nodes
7) add to queue button: click to add the currently selected write nodes to the job queue without starting the render process
8) close button: click to close the smartRender window
you can save your currently selected render settings as a preset to quickly jump between different render settings. Each preset saves the following settings:
• frame range
• incremental steps (frames to skip while rendering)
• whether to overwrite existing frames or not
• number of threads to use for processing
• render size
Please note: Your currently selected state of render settings in your output tab is saved even if you close smartRender, NUKE and even if you shut down your computer.
If you want to save your current settings as a preset simply click the "add" button. In the upcoming window please choose a name for the new preset. Finally click the "ok" button. If you type in a preset name that already exists you are asked to confirm to overwrite it. So you can update your existing presets as well.
To load a preset first choose the desired preset from the preset list. Below you will see a description of all saved settings. If you like to load this preset simply click the "load" button. Your currently set render settings will be replaced with the chosen preset's render settings.
To remove a preset simply choose the desired preset from the preset list and click the "remove" button. You are asked to confirm removing the preset. By clicking the red "delete" button your preset will be remove. Please note that this step can't be undone.
The output section lets you define your rendering settings including frame range, incremental renderings, thread count, output size and write nodes to render.
The output section contains 8 elements:
1) frame range: Here you can set the frame range to "global" which will take your scripts frame range or you can set the dropdown to "custom" and reveal an input below in which you can set your custom frame range in the known format "startframe - endframe".
2) incremental: Here you can choose to render every frame or every nth frame. For instance if you wish to render only every other frame choose the "step" radio button and enter "2" inside the input. Or if you want to render only every 10th frame simply enter "10", and so on.
3) threads: Here you can choose how many threads to use for the rendering. The number is limited to the number of cores on your machine. For example if your machine has 4 cores then the maximum thread count in the dial will be 8. If you have 12 cores then the maximum thread count will be 24, and so on. If you choose "0" as thread count then the job will be processed as a "standard" NUKE rendering meaning a foreground rendering which will be a frame after frame process.
4) size: Here you can set an output size. If you set anything else than "full" then a reformat node will created automatically before rendering and will be piped in before your write node. This reformat node will then be removed automatically once the rendering is finished.
5) write nodes: Here you can choose which write nodes to process. If you select any write nodes and then open the smartRender main window then the according checkboxes will be checked automatically for you.
6) render button: Click the render button to start the rendering processes.
7) add to queue button: Click to add the checked write nodes to the job queue without automatically starting the rendering. The jobs are just added to the queue and you can start them manually by right clicking a job in the job history and choosing "job->resume job".
8) close button: Click to close the smartRender window.
Please note: All your render settings that you set in the output section are saved and remain even if you close smartRender, your NUKE session and even if you shut down your computer. You can use the preset list if you need to quickly change from one render setting to another. This saves you from editing all the inputs every time manually. To load a preset please refer to 4.2) Loading a preset.
If you right click on of the write nodes checkboxes in the write nodes section a right click menu will appear: 1) jump to [Write node Name]: click to jump to the write node in your nukescript. 2) open render directory in finder: click to reveal the write node's render directory if it is set
To start the rendering process double check if you have set all your rendering settings to your needs.
The checked write nodes in the "Write nodes" section at the bottom right of the output section are the write nodes that will be processed.
When you are ready to start your renderings simply click the blue "render" button. The job will be send to smartLib and all frames will be divided by the number of set threads and all frames will be rendered using a background rendering with multiple threads. By hitting the blue "render" button the rendering processes will start immediately. Right next to the render button you will find the "add to queue" button. By clicking it the job will be added to smartRender's job history but won't be started. This can be useful to collect all jobs that need to be done first (even collecting from different nuke scripts) and the starting the jobs manually by right clicking a job and choosing "job->resume job".
smartRender supports multi view processing (e.g. stereo projects). If you run smartRender in a nukescript that contains multiple views you will see all views in that script in the "Frame range" section at the to left. Simply check the needed views and hit the render button. The views will be rendered simultaneously.
The job history section shows you all jobs; weather they are finished, waiting or processing. All jobs are sorted descending by date. The latest job will be listed on top while older jobs are listed below. You can toggle the job history to show/ hide it by clicking the "L"-key.
The job table shows you the most important job details: 1) time: The date and time when the job was added to the job history
2) script: The processed nuke script for the job
1) write: The processed write node for the job
1) range: the set frame range for the job. This will be in the known format "startframe - endframe". If the job uses some incremental rendering then the incremental step will be listed in brackets. For instance rendering from frame 1 to frame 50 with rendering only every 10th frame will be displayed as follows: 1 - 50 (10)
1) status: The current status of the job. if it is rendering then a progress bar will be shown displaying the current render progress in percantage.
Right click the job table. This will reveal a menu containing the following commands:
1) refresh list: The jobs table will be refreshed all n seconds automatically where n is the number set in the smartRender settings under "update job history after seconds" (Please refer to 9) The smartRender settings). However by clicking this item the job history will be refreshed manually.
2) job: hover over "job" to reveal the job specific commands for the selected job. Detailed information can be found here: 6.2) The Job menu.
1) display: hover over "display" to reveal the display menu. Detailed information can be found here: 6.3) The display menu.
1) remove all finished jobs: Well, as the name would suggest.. remove all finished jobs from the jobs table. Please note: This does NOT physically remove the rendered frames.
Right click a job from the job history table and choose "job". This will reveal the job menu to execute some specific commands for the selected job:
1) resume job: Click to continue the job if it was paused. If the job was submitted with the "add to queue" button clicking the resume job command will start the job.
2) pause job: Click to pause the job. All threads that are rendering at that moment will continue rendering their frame and will then pause so that no new frame will be processed.
3) show log: Click to show the log for this job. For detailed information about job logs please refer to 7) The job log window.
4) open render directory: Click to open the render directory that was set for the write nodes file path for the selected job.
5) remove job: Click to remove the job from the job list. If the job is rendering at the moment the threads will be stopped so that they won't start processing new frames. Already rendered frame are NOT physically removed from your hard drive.
You can change the number of threads processing a job on the fly, also when the job is rendering, waiting and paused. Simply click the job menu's "resume" item (image above 1)) and in the upcoming window set a new thread count. The job will be processed with the entered amount of threads.
Right click a job from the job history or right click the table in an empty area and choose "display". This will reveal the display menu to view only jobs with a specific status:
1) all: Click to view all jobs
2) waiting: Click to view only jobs with the status "waiting". That are jobs that have been added to the job queue but haven't been started rendering.
3) paused: Click to show only jobs that have been paused from processing.
4) error: Click to show jobs that produced one or more errors while processing.
5) finished: Click to show only finished jobs.
Each job contains a log where you can find detailed information about it. To show a log for a job open smartRender, click the job history toggle at the top right to navigate to the
job history. Then choose a job from the list that you like to get more information on, right click it and choose "job->show log":
By clicking the command "show log" the job log window for this job will show up. The data in this window will be refreshed all n seconds automatically where n is the number that is set in the smartRender settings at "update job log after seconds" (Please refer to 9) The smartRender settings).
The job log window contains 7 elements: 1) job data: all job meta data including:
• internal job id as it will be processed internally by smartRender
• date and time of starting the job
• write node to process
• nuke script to process
• render directory as it is set in the write node
• frame range to render in the format "startframe - endframe". If the incremental render method was chosen the incremental steps appear in brackets.
• The current status of the job
• The render current progress of the job
2) resume job: Click to continue processing the job. After clicking you can decide how many threads to use for processing. 3) pause job: Click to pause the job. Frames that are rendering at the moment of pausing will be finished processing but no new frames will be processed. 4) export job log: Click to export the job log to your hard drive. For more information please refer to 7.1) Exporting the job log
5) refresh: Click to manually refresh the job log. Please note that the job log will be refreshed automatically. This button serves to do that step manually as soon as you click it.
6) log dropdown: Click to reveal all the different log information including:
• job: all: show all job log information
• job: info: show only job info details
• job: done: show only frame finished rendering details
• job: error: show only rendering error details
• pending frames: show only frames that haven't been rendered so far
• terminal input: show only terminal input commands that will be generated by smartRender and send to NUKE's terminal
• terminal output: show only terminal output commands that will be generated by NUKE's terminal
7) log: The log information.
8) open render directory button: Click to show the render directory as it is set in the job's write node's file knob.
9) close: Click to close the job log winodw.
Each job log can be exported to your hard drive as a text file. To export a job log please click the "export" button at the top right of the job log window: A file browser will show up which lets you can choose a location and a file name for your log to export. The log will be exported as a ".txt" file on your hard drive. It contains the job details, the job log, terminal input commands and terminal outputs.
You can enable render notifications to get informed when your background renderings have finished. smartRender offers two render notifications which can be enabled independently from each other: visual notifications and accoustic notifications.
To enable the notifications open smartRender's settings window by navigating to your menu bar and choosing: "cragl->smartRender->settings". In here you can enable/ disable:
1) show render notification: If this checkbox is set a notification window will pop up. The notification window is documented below in 8.1) The Render notifications window.
2) render finished sound: Play a sound when the rendering is finished. If set to 'no sound' then there will be no notification sound.
Please note: You can also put your own .WAV sound files into the 'sounds' directory of the smartRender module and choose your own custom sounds to play when the rendering is finished.
When a rendering is finished you will get a render notifications window that lets you choose from some actions:
1) open render directory: Click to open the render directory as it is set in the job's write node's file knob.
2) insert as read node: Click to insert the rendering as a read node into your dag.
3) show log: Click to show the job log window for this finished job.
To enable/ disable the render notifications open the smartRender settings via "cragl->smartRender->settings". In the upcoming window enable/ disable "show render notification" to your needs.
To open smartRender's settings navigate to your menu bar and choose "cragl->smartRender->settings":
smartRender contains a variety of settings to customize it to your needs: 1) enable backup: If this checkbox is checked save a backup of the current script into the backup directory before starting the render process. The script will be saved to: ~/cragl/smartRender/backups. The script will be saved as: jobID_name-of-script.nk. Please note: If this checkbox is enabled then all worker threads will process the backup file. This means changing your nuke script while it is being processed doesn't have an effect on the overall rendered images. However if you disable the checkbox then the worker threads process your current nuke script which means that if you change anything in it while it is being processed this will actually affect the rendering. This can become useful to make changes to your nuke script on the fly while it is being rendered.
2) force create render directory: If this checkbox is checked the render directory will be created automatically if it doesn't exist. This is to prevent renderings from not starting because of a missing render directory because by default if a render directory doesn't exist NUKE won't process the rendering. By checking this checkbox it will always be guaranteed that the render directory exists.
3) show render notification: If this checkbox is checked a notification window will pop up that contains some action to choose from. For more information about the render notification window please refer to 8.1) The Render notifications window
4) output terminal commands: If this checkbox is checked all generated commands (one command per line) that will be executed in NUKE terminal mode are written to:
All nuke terminal outputs are written to:
You can either browse directly to these files or show the terminal inputs and outputs in the job log window by navigating to the render history, right clicking a job, selecting 'job->show log' and choosing 'terminal input' or 'terminal output' from the log filter drop-down menu.
This option is for error checking and script debugging purposes. If your renderings won't start then copy one of the lines of the terminal_input and paste them into your terminal to see what is causing the rendering from raising errors. The terminal_output can also give valuable information about rendering errors. Please also have an additional look at the general job log.
5) after submitting: Choose what action to process after hitting the 'render' button in the smartRender main window. These options are available
• show message + show job history
• show message + show log + close smartRender
• show message + close smartRender
• show message
6) render finished sound: Play a sound when the rendering is finished. If set to 'no sound' then there will be no notification sound.
Please note: You can also put your own .WAV sound files into the 'sounds' directory of the smartRender module and choose your own custom sounds to play when a rendering has finished.
7) update history after seconds: Automatically update the render history that shows all jobs after x seconds. This setting should rarely need to be changed.
8) update job log after seconds: Automatically update the job log that shows the log information for the current job in the job log window. This setting should rarely need to be changed.
9) nuke executable: Use this nuke executable for the rendering. The default executable targets to your currently used nuke version. However if you need to change the executable to another version then you can set it right here. Please note: This input will be set to it's default value after re launching nuke.
10) flush jobs: Use this button to flush all jobs from the jobs list. Already rendered frames are NOT being removed from your hard drive. If you do that while a job is being processed it will be stopped.
11) reset settings: Use this button to reset the smartRender settings. Please note: This will also remove all presets. This action can't be undone.
12) save and close: Click to save the current settings state and close the settings window.
smartRender works out of the box producing fast render results. However you can customize the actual render process command modules to your needs.
If you have some python programming knowledge then you can edit the command modules and add your own commands to them.
This can become very useful if you need to tailor smartRender to your existing pipeline. Feel free to edit both command modules.
smartRender includes two modules that you can edit:
renderCmd.py: This module creates the terminal input commands
renderProcess.py: This module will be executed from your terminal when it comes to processing a frame
Both modules can be found inside the "custom" folder in the smartRender package. If you installed smartRender using connect it can be found here:
If you installed smartRender using the manual method then the custom folder can be found at the according location inside the smartRender package.
CAUTION: CHANGING BOTH MODULES COULD POTENTIALLY BREAK SMARTRENDER FROM WORKING CORRECTLY. WE HIGHLY RECOMMEND MAKING A BACKUP OF BOTH MODULES BEFORE CHANGING THEM. PLEASE HANDLE WITH CAUTION.
The renderCmd module contains one function create_cmd() which form a render command for the worker threads which will execute it in NUKE's terminal mode. The command is returned as a String.
By default a render command is build of NUKE internal flags and some additional arguments and looks like this:
"nuke_exe" -i -t renderProcess.py job_id thread_id script write frame views
• nuke exe: String absolute path of nuke executable that will run in terminal mode
•-i: use an interactive (nuke_i) FLEXlm license key
•-t: run in terminal mode
•renderProcess.py: String absolute path to this render batch script that will be processed
•job_id: String unique job id for identifying the current job in log file and writing process to log file. A job id looks like this: current_timestamp_unique-job-id. Example: 1460975662_facc80e8
•thread_id: String id of thread that will process the current job. Threads are named as Thread-1, Thread-2, Thread-3, ...
•script: String absolute path of nuke script to process
•frame: String frame to process. Named as f1 for frame 1, f2 for frame 2, ...
•views: String views to render. Multiple views are separated by comma like Main,left,right,...
the first three flags (nuke executable, -i, -t) are nuke internal flags that will be called.
• The nuke executable is pointing to the absolute path of the executable nuke application that will run in terminal mode.
• The nuke executable will be executed using the "-i" flag to use an interactive (nuke_i) FLEXlm license key.
• The nuke executable will run with the "-t" flag which means it will run in terminal mode without any GUI (graphical user interface) being loaded.
The following arguments are additional arguments that will be used in the renderProcess module which is documented in 10.2) The renderProcess module.
• renderProcess.py: The absolute path of the renderProcess module that will be executed.
• job_id: This is the internal job id as it will be used for logging information.
• thread_id: This is the internal thread id as it will be used for logging information.
• script: absolute path of nuke script that will be opened in terminal mode and executed.
• frame: Frame to process. The frame will need to be casted as a String for being send as an argument and will look like "f1" for frame 1, "f10" for frame 10 and so on. Once being in renderProcess.py this String will be casted back to an integer like 1, 10, ...
• views: Views to render. The default is "Main".
The NUKE terminal documentation can be found here:
A list of additional NUKE internal flags please can be found here:
The renderProcess module will be executed in NUKE's terminal mode. Each thread calls this render batch script.
The module includes two functions: framelog() and render().
framelog: This function creates an std out which will be fetched internally by smartRender to write log information.
render: This is the render function that will be executed to process a frame. Inside the function these commands will be executed:
• re cast the frame argument back to an integer
• open the nuke script
• check for some script errors (disabled write node, error in tree) and log the information about the frame that was processed
• try to render the frame and log the information
Here you will find some frequently asked questions on smartRender. Please make sure to read them first. Please also have a look on the documentation. If you have any question that is not listed in here please don't hesitate to contact us. We are pleased to help you.
Each cragl tool can be installed via cragl connect - our free tool to install and manage all of your cragl tools directly inside NUKE. If you haven't already done so please download connect.
By opening connect you will see a list of all cragl tools. You can drag and drop it to the right hand side of the connect window to reveal more infos. Just click on "buy". After purchasing you will receive an install code for your tool. Now simply click "install now" and enter the received install code. The tool will be downloaded and installed automatically for you. So you don't need to struggle with any install issue.
Please check these steps:
1) Please check your job log. Any error should be reported in here.
2) You can see what the terminal will execute by doing the following: Export your job log, open it and copy one of the lines of the terminal "input section" (1 line is one command - you will probably need to expand your file to fullscreen to grab one whole line). Paste the copied line into your terminal and have a look at the output. If there is some problem it will appear in here.
3) Please contact support and send us your scene, we are happy to help
If you use gizmos in your script please try to convert them to groups ("node" tab -> button "convert to group"). The reason behind this is simple: as the multi threaded rendering is executed in terminal mode each nuke session that processes a frame launches in terminal mode and doesn't load your menu.py file in which your gizmos are most likely loaded. If it comes to processing a frame your nuke session will raise an error if there is a gizmo inside your processing tree as the gizmo hasn't been loaded because your menu.py wasn't loaded. So please try converting your gizmos to groups. It's anyway a good habit to convert all gizmos to groups that so your nuke script is flexible and is transferable to another computer on which the gizmo will probably not be installed.
If you set a high number of threads and your scene is quite heavy your computer is likely to slow down and blocking. This is completely normal as you told your computer to render several frames simultaneously. If you experience a complete slow down and your computer doesn't respond for a long time chances are high that your computer is getting some memory overflow. This is likely to happen on huge nuke scripts where you use multiple threads. To solve this try reducing the number of used threads for that job. Furthermore if you decide to use all available threads for rendering try to shut down other unneeded applications.
Here you will find an overview of the smartRender's versions and its improvements. Please log in to download versions.
• fixed bug that caused an error when rendering using -keep existing frames- enabled
• Render info panel to quickly access and edit your renderings
• Batch render multiple shots
• Rendering external nuke scripts without opening them
• added global node changer window
• added automatic cache write node creator
• added input mode to frame range in smartRender window
• first beta