3.0.5546 is here: Parameter hints, the ultimate type inference and more


Brace for another totally skookum release of your favorite game scripting language, compatible with 4.13 through 4.18!

What’s new?

In a nutshell

  • The IDE now has a parameter hint popup that assists you entering invocation arguments
  • Instantiations can now infer their class that means e.g. if a routine my_method(Vector3 direction) expects a Vector3 argument, and you would like to pass the up vector, you can simply say my_method(!up) instead of my_method(Vector3!up).
  • You can omit class qualifiers from class methods if the expected class is known, e.g. instead of my_func(Real.abs(num)) you can now simply say my_func(abs(num))
  • List literal now infers the list class type and the list item type if it isn’t specified and the desired list type is known - so the following example code will allow lists with String and Integer but not Real:
    !list_arg: (List{<Integer|String>} list)[println(list)]
    list_arg({1}.append("two")) // Ok
    list_arg({1}.append(3.0)) // Error
    !list_arg: (List{<Integer|String>} list)[println(list)]
    list_arg({1} + {"two"} + {3.0}) // Error (since 3.0 is neither Integer nor String)
  • Added nil coalescing operatorexpr1??expr2
    !f: a ?? b
    // Which means
    !a_result: a
    !f: if a_result.nil?
        [b]           // Should match type of a_result<>
        [a_result<>]  // None type removed  
    // Or if dupe result not an issue:
    !f: if a.nil? [b] else [a<>] 
  • A number of new handy math methods for the Real and Integer classes
  • The SkookumIDE now supports high DPI displays, looking nice and crisp on your retina display!

Detailed release notes


  • new parameter hint popup
  • now supports high DPI displays
  • modified editor word breaking logic so that it does not treat comments, strings or symbols as an unbroken atomic block
  • print more feedback to the IDE Log when building: commit, compile, force compile
  • fixed bug where editor settings dialog would not immediately apply its tab stop settings to the Slate text shaper
  • fixed bug where warning dialog popup would sometimes not work
  • fixed bug in member creation function

Skookum UE4 Plugin

  • fixed bug where 4.18 would crash on startup trying to check out a file from source control before the main frame window is up
  • fixed issue where UObjects created from yet unpatched BlueprintGeneratedClasses would cause crashes when their embedded SkInstance is accessed
  • fixed crash when trying to destroy SkInstance of already destroyed object
  • fixed issue with SkookumScriptBehaviorComponents sometimes zeroing out their object pointer
  • modified SkUEClassBindingHelper::initialize_array_from_list() so that it initializes array elements using default constructors which ensures that types being assigned values such as FString work properly
  • disabled class WeightedBlendables in 4.17 because it was causing issues with the MP build for unknown reasons


  • instantiations now infer their class if sufficient context is available to determine the desired type
  • added nil coalescing operator expr1??expr2
  • removed Char class which was not used. Use a substring of the String class instead.
  • fix to closure parse when result type is specified
  • fixed bug where parse probe was not properly set after parsing of an invocation (now properly set to the return type of the invocation)
  • fixed SkInvocation::as_code() so that it includes a member accessor . for instantiation receivers.
  • added nil coalescing runtime expression object
  • added more context information for class meta info !Class.sk-meta unknown key errors
  • ensured that args structure is passed down the chain from SkParser::parse_parameters() to SkParser::parse_parameter_unary() so that auto-complete and hints will have more information
  • modified code block parsing so that if desired type is known when a block is given, to retain knowledge of the desired type for add on calls/stringization after the block
  • added defer as future reserved word
  • updated list literal to infer the list class type and the list item type if it isn’t specified and the desired list type is known. So the following example code will allow lists with String and Integer but not Real:
    !list_arg: (List{<Integer|String>} list)[println(list)]
    !list_arg: (List{<Integer|String>} list)[println(list)]
    list_arg({1} + {"two"} + {3.0})


  • constant value constructors for Real: !golden_ratio(), !infinity(), !max(), !min(), !meter(), !nan(), !pi()
  • new scalar math methods for Real
  • constant value constructors for Integer: !max(), !min()
  • new scalar math methods for Integer
  • removed empty Char class (should just use String)
  • new EntityClass methods entity_class_of?(), entity_subclass_of?(), entity_superclass_of?(), equal?(), not_equal?()
  • Integer.bit_set?() fixed typo in comment
  • revised defaults to take advantage of inferred classes

Get the new plugin from the Unreal Marketplace, our GitHub repository or as a good old precompiled zip file for Epic Games Launcher users.

As usual, don’t hesitate to ask us for help if you encounter any issues!


SK equivalent to TSubclassOf and BlueprintPure

Looks like some great stuff in here =)


This is a great news! Thanks a lot guys!