• The "Project" tab, which allows you to enter general information about the project.
• The "Analysis" tab, which allows you to associate one or more analyses with the project and/or a UML model.
• The "Data files" tab, which allows you to enter information about the data files used by the application. This tab is only available if the project uses an analysis.
• The "Live Data" tab, which allows you to configure how the data from the data files is displayed in the different editors.
• The "Languages" tab, which is used to configure the different languages used by the project as well as the options to be used for each language.
• The "Style" tab, which allows you to customize the print preview and to choose the skin template and custom style sheet. You can also configure screen sizes.
• The "Skin" tab, which allows you to choose the project skin, the associated palette, style sheet and external resources.
• The "SCM" tab, which is used to manage teamwork (SCM or Git).
• The "Options" tab, which allows you to define the creation, update and save options of the different elements of the project. This tab also allows you to synchronize templates, enable strict mode and define the code style.
• The "Advanced" tab, which allows you to enable "Reports and Queries", configure the AAFs and lock the application.
• The "Compilation" tab, which allows you to configure the compilation options.
• The "Telemetry" tab, which allows you to configure the telemetry options for the project.
  This option is not available.

General options

• Recompile project before generating applications, libraries, components, etc.:
  This option compiles the project before each major operation on the project. This option is recommended to generate multiple elements from a project.
  This option is also available in all deployment wizards (creation of an executable file or library, generation of multiple elements, etc.).
  Note: The application's compiled code directory will be created in a subdirectory ("<Project_name>.cpl") of the compilation directory. This compiled code directory contains the compiled code files for each element of the project: windows, reports, queries, etc.

UI errors

Compiler options

• Compilation error on unknown identifiers
  Defines whether a compiler error is displayed when the compiler encounters an unknown identifier (window name, field name, etc.).
• Compilation error for elements outside configuration
  When this option is enabled, a compilation error appears when using elements that do not belong to the configuration in the code of the current configuration. The <COMPILE IF> statement can be used to manage code compilation according to the platforms and configuration types.
• Scope of local variables limited to the current block
  If this option is selected, local variables will be specific to the block.
  You cannot use a local variable outside the block in which it is declared.
  The variable is destroyed at the end of the block (frees memory).
  You can declare a variable with the same name in two different sub-blocks, but not in a child sub-block.
  If this option is enabled, the declaration of internal procedures using "scope-limited" variables will result in a generation error. Example:
  • the following code causes a compilation error:
    

    PROCEDURE MyProcedure()
    IF MyCondition THEN
        str is string // str exists only within the scope of the IF statement 
        INTERNAL PROCEDURE my_internal_procedure()
            str = "thing" // -> Will cause an error in Java/Android generation
        END
    END

  • To fix this error, the variable must not be declared in the IF statement:
    

    PROCEDURE MyProcedure()
    str is string 
    IF MyCondition THEN
        INTERNAL PROCEDURE my_internal_procedure()
            str = "thing"
        END
    END

  In Java and Android, it is recommended to always declare internal procedures in the scope of the procedure itself. Thus, the use of undeclared variables will raise compilation errors.
• Allow "[% %]" in strings:
  This option allows you to directly use a variable name in a string (also referred to as "dynamic string construction"). To do so, use the following syntax:
  
  [%VariableName%]
  For example:
  

  // Ask for customer confirmation
  IF YesNo(Yes, "Do you confirm the creation of customer [%sCustomerName%]") = No THEN
  	RETURN
  END

  Caution: Using this option may mean modifying the code for certain WLanguage functions that already use the "[% %]" characters in their parameters. In this case, to avoid interpreting the "[% %]" characters, they must be preceded by "-%". Example:
  

  grTooltip(GR_Deadline, grTooltipFormat, "[%CATEGORY%]" + CR + CR+ "[%VALUE%]" + " H")

  becomes

  grTooltip(GR_Deadline, grTooltipFormat, -%"[%CATEGORY%]" + CR + CR + -%"[%VALUE%]" + " H")

  For more details, see String interpolation.
• Subscription-exclusive new feature
  Allow simplified declaration of Window types:
  Allows the use of simplified syntax to declare variables associated with a window. Standard declaration syntax:
  

  <Window_variable_name> is Window <Window name>

  Simplified declaration syntax:
  

  <Window_variable_name> is <Window name>

  Note: The use of simplified syntax may require some adaptations in your code. For more details, see Manipulating a window using its type.
  Note: This feature is only available in subscription-based versions, starting with WINDEV Suite 2025 - Update 4.
  For more details, see Using new features exclusive to the subscription-based version of WINDEV Suite 2025.
• Allow nullable types:
  Enables nullable types in a WINDEV, WEBDEV or WINDEV Mobile project. Allowing nullable types in a project changes the way your project handles null values. For more details, see NULL values: Allowing nullable types.
• Classes: Optional ":" and "::" prefixes for accessing members and methods
  Until version 14, the accesses to the members had to be performed by using the ":" and "::" prefixes. If this option is checked, these prefixes will not be required anymore.
• Classes: Make methods of the same name virtual
  Methods with the same name in derived classes are virtual.
  The "semi-virtual" mode kept for backward compatibility with WINDEV 4 and 5 is no longer available.
  The "virtual" keyword has no effect. There are no notifications for virtual methods when the "virtual" keyword is not specified.
• Classes: Pass instances as parameters by reference ("dynamic" keyword no longer required)
  This option enables you to use a more concise syntax for base class parameters.
  You can write:
  
  PROCEDURE MyProcedure(Param is BaseClass)
  instead of:
  
  PROCEDURE MyProcedure(LOCAL Param is Dynamic BaseClass)
  If this option is checked, the <- operator becomes invalid.
  To change the local reference use the following syntax:
  
  PROCEDURE MyProcedure(LOCAL Param is Dynamic BaseClass)
  To return a reference to the caller, use the following syntax:
  
  PROCEDURE MyProcedure(Param is Dynamic BaseClass)
  Note: Using the LOCAL keyword alone creates a copy of the instance.
• Arrays: Deep copy
  This option makes arrays local by default. This means that the '=' operator performs a deep copy of the values in the array.
  If necessary, you can use the "dynamic" keyword so that the arrays point to the same reference.
• Arrays: Protected access to elements passed as parameters to a procedure
  This option protects an array element passed to a procedure as a parameter. You can modify, delete or add elements to the array from this procedure.
  Note: When enabled, this option may slow down access to the array.
• Optimization: Enable inline expansion:
  This option speeds up code execution. Whenever possible, the compiler automatically replaces the procedure call with its code. This may result in an overall increase in code size, but faster procedure calls.
• Optimization: Optimized evaluation of boolean expressions (AND, OR, IN):
  This option changes the old behavior of boolean expressions:
  • If this option is checked, logical operators will be optimized by default. If the first part of the expression determines the result, the second part is not evaluated. Starting with version 2024, this option is enabled by default for all new projects.
  • If this option is disabled, the legacy mode is preserved. This means that all the elements of the expression will be evaluated. To use an optimized mode, it is necessary to use the _AND_, _OR_, _IN_ operators..
  For more details, see Logical operators.
• "Data source names":
  • "Variable name":
    "Data source" variables create a data source that use the name of the variable. This may cause a problem in the following cases:
    • use of arrays of data sources
    • use of data sources as class members.
    • Data Source variable used simultaneously by two windows.
  • "Automatic name":
    "Data Source" variables use a unique name for the data source. Please note quotation marks must be removed to manipulate the data source. Don't write:
    
    M1 is Data Source
    HReadFirst("M1")
    but
    M1 is Data Source
    HReadFirst(M1)
  • "Automatic name with references":
    "Data Source" variables use a unique name for the data source. It is now possible to reference an existing data source, for example using the following syntax:
    
    x is Data Source
    x = FileName
    x = QueryName
    The NULL value is supported.
    The "Automatic name with references" option is not available.

These compilation options are taken into account in Java and Android.