Digital transformation

Artificial Intelligence

In the early phases of a design, engineers are forced to make decisions that can have an irreversible impact on later design stages. Due to limited time and data, these design decisions are never optimal. This leads, for example, to ships with higher building and operational costs than actually needed. Especially with regard to current sustainability ambitions and economic conditions, this problem has become more and more relevant to date.

Roy de Winter, R&D Engineer at C-Job Naval Architects, says “That is why it's important to find a way to make these decisions in a data-driven way. An optimization process is difficult and labor-intensive but very essential to ensure reliable and efficient results. Together with the VIKTOR platform, we were able to create a web app , the ACD resistance module, that optimizes this process and reduces building and operational costs.”
With the ACD resistance module, a ship’s hull is optimized based on its resistance, which in turn will result in superior building costs (CAPEX) and operational costs (OPEX) for ship owners. Together, this creates a ship design that ensures the delivery of the highest design quality in the shortest amount of time: up to two times faster than before. With the web app, chances of having to make any changes later in the process based on key decisions made earlier in the design are reduced to almost zero, resulting in an overall smoother process of the whole ship design.
The two companies were a perfect match for the creation of this web app. With C-Job's experience in R&D, data science, and coding, the company knew exactly what input was needed. As a software company with engineering DNA, VIKTOR helped them bring C-Job's vision to life with their team of developing engineers that offer expertise and co-development throughout the process of turning the idea into a usable web app with Python.

Roy continues “Working together with VIKTOR, we were able to build an easy-to-use web app that combines all our knowledge into a one-stop cloud-based solution for our engineers. The creation of the web app could not have happened without VIKTOR, they were essential to making the ACD Resistance Module what it is today.”

Wouter Riedijk, CEO and co-founder of VIKTOR, says “We strive to never stop exploring new ideas and technologies and were excited to collaborate with C-Job on a solution that helps unlock engineering potential to an exponential degree. Through the VIKTOR interface, engineers can turn any idea into a cloud-based, interactive, user-friendly, that is accessible to anyone.”

The ACD Resistance Module operates via the VIKTOR platform which offers a user-friendly interface where multiple users can work on projects. VIKTOR takes care of the UI, while C-Job's domain knowledge is running behind the scenes. 

To find out more about the web app and other work by C-Job and VIKTOR, please visit [www.c-job.com](www.c-job.com) or [www.viktor.ai](www.viktor.ai)


medium_Group 181 (1).png

small_Group 181 (1).png

thumbnail_Group 181 (1).png

Group 181 (1).png

An international ship design company and a Dutch software company have joined forces to create a software program to optimize the hull design process, making it up to two times faster. 

New ship design tool reduces lead time up to 50%

## Get the white paper

**INDEX**

1. Construction companies and digital transformation
2. Technology trends for a different approach
3. Technology trends in the construction industry
4. A new technology trend for the construction industry
5. Low code for the construction industry
6. The VIKTOR platform
7. What does it cost?
8. How to start
9. What's next?

small_White Paper Digital Transformation Engineering and construction industry.jpg

thumbnail_White Paper Digital Transformation Engineering and construction industry.jpg

WP_dark_blue

large_gravity-based foundation application.jpg

medium_gravity-based foundation application.jpg

small_gravity-based foundation application.jpg

thumbnail_gravity-based foundation application.jpg

Customer_case_centralizing_data_faster_gravity_based_foundation_analysis_2


What are the current trends in digital transformation and how do they affect the engineering and construction industry? 

This white paper is for every engineer, manager, director, or anyone else that wants to learn more about (new) technology trends that help boost digital transformation in engineering and construction, such as BIM, parametric or generative design, and low-code and no-code. 

Discover how web applications can help you find the best solution fast, get the best insights, capture knowledge into assets, and make work more joyful! 






Learn about trends in digital transformation and how they affect the engineering and construction industry.

Download the White Paper and get INSPIRED

This white paper is for every engineer, manager, director, or anyone else that wants to learn more about (new) technology trends that help boost digital transformation in engineering and construction, such as BIM, parametric or generative design, and low-code and no-code. 

Digital Transformation: Engineering and Construction Industry

Creating Apps & Python

## What is RFEM? 

If you're reading this, you probably already know what RFEM is. If not, let us explain quickly. 

RFEM is a 3D finite element analysis software by Dlubal, made for structural analysis and design and, amongst others, the generation of steel, and concrete structures. With RFEM, structural engineers can easily create everything from simple to complex models and perform structural and dynamic calculations.

## RFEM’s new WebService 

More frequently, engineers start looking for possibilities to customize and automate their structural analyses and designs. That’s why Dlubal created a WebService that offers remote communication with RFEM over web protocols, using Python or C#. It works like an API and enables engineers to use RFEM beyond, and without, its graphical interface. This way, you can automate (part of) your workflow or even create a custom parametric design web application. 

## Why a parametric RFEM web application? 

Imagine that you are an engineer who is designing warehouses, tanks, silos, staircases, or anything else for that matter. All your designs are different to some extent, but not that much. In the end, you follow the same design process to create and validate every design and make a quotation, some reports, and drawings. With a repeating process like this, would it not be great to have a parametric design tool that does all of this for you? And would it not be even greater if your colleagues could also use this tool all by themselves, so you have more time to focus on other, more challenging, and fun parts of your work? 

If this sounds interesting, we recommend using Python to create a parametric design tool like this. Besides automating large parts of only your ‘boring’ (read: repetitive) work, a user-friendly web application with a custom user interface makes it possible for those without Python experience to automate processes as well. On top of that, an online application is a perfect way to distribute your data. You can authorize anyone with an internet connection to use your app, you can be sure that everyone is always using the correct version of the model, and you keep your intellectual property protected, as you won’t have to share any code. You may be thinking: “That sounds awesome but is this not difficult to manage?”. No worries, not with VIKTOR. Just keep reading… 

## What is VIKTOR? 

VIKTOR is an online application development platform that enables you to create your own web applications using nothing but Python. It seamlessly integrates with RFEM, and so much more software products!  

Here are some of the biggest benefits of VIKTOR: 

**Easy & fast:** VIKTOR is like a box of digital building blocks you can assemble to create your own apps. With Python, you can use the full functionality of RFEM and VIKTOR, making it easy to build powerful and user-friendly applications quickly. 

**Accessibility:** Thanks to the user-friendly and intuitive interface, non-specialists can also use your apps. Anywhere in the world. All you need is an internet connection.  

![RFEM & VIKTOR 1.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_1_50940ca15d.png)

</br>

**Hyper automation:** You can build apps customized to fully automate your workflow, connect with multiple software packages, and include all kinds of visualizations, optimization routines, reporting, and much, much more. 

![RFEM & VIKTOR 2.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_2_16c0cbb923.png)

</br>

**Integrate with other software:** Through VIKTOR, it becomes possible to use RFEM together with (several) other products like Excel sheets, other software for structural engineering, soil mechanics, 3D modeling, and the complete Python ecosystem. 

**Focus on what matters:** VIKTOR takes care of all the non-engineering parts of creating apps, like creating a user management system, hosting and cloud infrastructure, database, backups, and security patches.   

## What about detail engineering and specials? 

We know it is very difficult to create a parametric design tool that covers all cases. Fortunately, this is no big deal if your tool does 95% of the work for you. Once the basic design is finished, you can simply download the RFEM models from the application and work on them via the RFEM user interface like usual. The only difference is that this time, you don’t need to start from scratch! 

Here you can see a simplified version of part of the data from RFEM in the VIKTOR interface: 

![RFEM & VIKTOR 3.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_3_36ba2d4521.png)

</br>

Versus the complete model in RFEM: 

![RFEM & VIKTOR 4.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_4_4485d75543.png)

</br>

## The RFEM-VIKTOR app explained 

Here is a short explanation of how this app works.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/802995926?h=4556d93899&badge=0&autopause=0&player_id=0&app_id=58479/embed" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen frameborder="0" style="position:absolute;top:0;left:0;width:100%;height:100%;"></iframe></div>

</br>

1. **Design in VIKTOR:** Using the app starts with the creation of a frame (truss) design in VIKTOR, which can be seen in the view on the right side of the application. This is a generic model with nodes and members. Users can also optimize designs by selecting a minimum and maximum truss height and the number of steps. Based on this input, the application iterates over these parameters and calculates results using RFEM. After all the calculations you can view the results in both a table and a figure. You can then select the best design. 

2. **Complete calculation with RFEM:** When you are happy with your design you can send the model to RFEM for calculations. In RFEM, the design is processed, and all desired information is automatically separated and returned to VIKTOR in a clear overview.  

3. **Analyze:** When RFEM has finished all the calculations, you can choose the values you want to display on your design model. For example, you can do a unity check to determine the forces on the model (displayed with corresponding numbers and color code in the view). On the right side of the application, you can find data with information retrieved from RFEM. 

Calculations take longer the bigger your model is, also more steps for optimization equals more calculation time. Keep that in mind while running the application for yourself. 

## What is next? 

RFEM is a powerful tool for structural analysis, designs, and calculations. Combining the best qualities of RFEM with an intuitive interface on the VIKTOR platform makes the quick and easy generation of structural models and performance of structural analysis and calculations accessible for anyone. No need for any experience with RFEM or programming (with Python)! 

You can now build your own RFEM – VIKTOR app by signing up for a [free VIKTOR account](https://www.viktor.ai/start-building-apps)!  


large_Group 177.png

medium_Group 177.png

small_Group 177.png

thumbnail_Group 177.png

Group 177.png

We have integrated RFEM’s Webservice and API with VIKTOR to make building user-friendly applications for structural design and analysis easier than ever!  

Tailored and accessible structural design and calculation software 

RFEM and VIKTOR: Tailored and accessible structural design and calculation software 

### Content: 

1. An introduction to developing successful applications
2. Designing and planning your application
3. How to start coding
4. Gathering and processing feedback
5. Increasing the adoption of your app



How to create successful application that ensure adoption

medium_White Papers & guides - Building succesful applications.jpg

small_White Papers & guides - Building succesful applications.jpg

thumbnail_White Papers & guides - Building succesful applications.jpg

WP_pink

How to create a succesful that people will adopt

large_White Papers & Guides - Building Succesful applications

medium_White Papers & Guides - Building Succesful applications

small_White Papers & Guides - Building Succesful applications

thumbnail_White Papers & Guides - Building Succesful applications

WP_pink_2

Do you want to build a successful application? This guide is here to help you make apps that provide real value to your work and that other people will definitely want to use too!

This guide will provide actionable insights that are useful for anyone involved in creating custom software tools, such as:

- **People developing the tools** (developers, engineers, data scientists, etc..)
- **End-users**, who will use the tools when they are released
- **Project managers** who are interested in workflow automation/optimization
- **Program managers,** who oversee and stimulate digital transformation initiatives
- **Domain experts**, who provide their expertise to people creating software tools
- And **anyone else i in the process of creating awesome software tools**

Over the past years, we, the application developers at VIKTOR, have built many apps for many different industries. We have learned a lot from that and now want to share our experiences with you. 

The principles and processes we explain in this guide are the same as we apply daily. They have helped us build anything from simple apps designed to save time to advanced engineering applications that are used to automatically calculate underground tunnels, dikes, and other large structures. 





Learn how you (developer, engineer, end-user, domain expert, project manager, etc.) can contribute to the creation of apps that provide real value to your work.

Build successful applications

This guide provides actionable insights for anyone involved in the creation of apps, such as engineers, developers, end-users, project managers, and domain experts. Learn how you can contribute to creating apps that provide real value to your work!

Building Successful Applications

VIKTOR updates

Keep reading, this article includes everything you need to know about the VIKTOR platform, our community, and how you can publish and share your own apps for free!

## What is VIKTOR?  

For those who don’t know us yet, VIKTOR is a platform that enables engineers and other domain experts to rapidly create and deploy web apps with nothing but Python. VIKTOR apps are known for their user-friendly interface, and are therefore accessible to a broad audience. This makes VIKTOR the perfect platform to create tools for your organization that virtually anyone can use! 
 
Engineers use VIKTOR to automate workflows and simplify complex tasks, giving them more time and flexibility to analyse different scenarios, reduce risks, and generate better designs. A nice example is this application by COWI for the automation of the design of the world’s longest immersed tunnel that connects Germany to Denmark: [The Fehmarnbelt tunnel](https://www.viktor.ai/customer-cases/33/parametric-design-automation-python-tunnel).  

## Community 

VIKTOR is more than just a tool to create and share engineering apps. We are also a community of like-minded individuals who are passionate about engineering and dedicated to advancing the field.  

> “We invite everyone interested in engineering and Python to join the community and share their apps with the world. Your contribution can make a real difference in advancing the field of digital engineering and inspiring the next generations.” - Anande Bergman, Head of Developer Relations  

We are thrilled to offer this new feature and are looking forward to seeing all the awesome apps created by the community! 

## Create and share your VIKTOR apps, for free! 

For the sake of completeness, let us start the journey of building a web-based app using VIKTOR. Here follows a – albeit condensed – guide to going from an idea of a web app to publishing your application. You can also watch this video to see the steps and follow along. 

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/803872551?h=d46b4da04a&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Tutorial - Publish VIKTOR apps"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

### 1. Getting started

Whether you have a Python script lying around, or a wild idea that still needs to get form in a web interface, to transform your script or idea into a VIKTOR app, you would need to [get your free developer account](https://www.viktor.ai/start-building-apps). 

After creating your account, you will be guided by following the installation steps, experiencing a demo app, and pointing you towards following a tutorial to build your first VIKTOR app.

### 2. Develop your own app 

Now that you have a good understanding of how to build a VIKTOR app, you can take the step to converting your script or idea to a VIKTOR app. Although the demo app and tutorial show you some elements of what the VIKTOR platform provides, there is still much more possible. So, refer to the [documentation ](https://docs.viktor.ai/) to read up on everything that the SDK provides or consult our [Community Forum](https://community.viktor.ai/). 

If not yet clear from the tutorial, you develop your app within the Development tile in the VIKTOR workspaces environment. 

![developer enviroment.png](https://cms.viktor.ai/uploads/developer_enviroment_2e51c0aa12.png)


### 3. Publish your application 

Once you are satisfied with the app you’ve created, it is time to take the next step: get your app online. This process can be defined in three steps: 

1. Create an app on your VIKTOR environment 
2. Publish your code on the created app 
3. Create a workspace to use the app

Now, let us dive into these steps in more detail.

#### 3.1. Create an app

For the VIKTOR platform to be able to host your application, it needs some information. To do that, you need to create an app on your VIKTOR environment. Here are the steps to follow: 

- Go to [cloud.viktor.ai ](https://cloud.viktor.ai/)
- Click on the 'Apps' tab under the 'Develop' section (on the left) 
- Click on the 'Create app' button and follow the instructions. 

![free apps step 1.png](https://cms.viktor.ai/uploads/free_apps_step_1_02e1b4f681.png)

</br>

#### 3.2. Publish your app

Now that you have app “container” available on your VIKTOR environment, you can upload your code from your computer to the cloud. For that, you will open or return to the terminal at the location of your app folder or project. You may recall that you used the `viktor-cli` to install and start your application. You will now use the `viktor-cli` again, though this time for publishing purposes. 

First, check whether the app you just created is listed as available. This can be done by using the following command: 

```bash
viktor-cli apps 
```

This will provide a list of app names on which you can publish your code. 

Next, use the following command to publish: 

```bash
viktor-cli publish --registered-name <app-name> --tag <tag> 
```
So, let’s say that you named your app “my-awesome-app” in the previous step. You would then publish your app using the command: 

```bash
viktor-cli publish --registered-name my-awesome-app --tag v0.1.0 
```

If all goes well, you’ll see the following happen: 

![free apps step 3.png](https://cms.viktor.ai/uploads/free_apps_step_3_48d03a5023.png)

If all went well, you will receive the message that you have successfully published your app. You can also inspect the status of your app by referring to the “Details” of your created app next to the tag you used. 

</br>


#### 3.3. Create a workspace

Congratulations, you have published your first app! But now a few questions pop up: Where can I see my app? What is the link to my app? For this, you need to follow one last step: create a workspace. In your VIKTOR environment, under the “Apps” section, you will see a button on the app that you have created called “Create workspace”. Follow the instructions after clicking on it will create a workspace where your app will reside in. 

![free apps step 2.png](https://cms.viktor.ai/uploads/free_apps_step_2_fe1e2dc3b5.png)

</br>

## How can I share my app?  

You can share your apps by simply copying and sharing your app's URL or using the share button at the top-right corner of your app.   



</br>

## Are my apps public? 

Yes, anyone that has your app's URL can use it. We would love to see a community in which everyone creates and shares apps that others can use too. Sharing your code, however, is not mandatory. But, of course, we really appreciate it if you are open to sharing your code on a public GitHub repository so others can view and use it as well! 

## Which app types can I publish?  

You can publish editor-type apps that consist of a single editor. This means every user gets a ‘fresh’ editor upon entry and data is not saved. This way, your app can easily be used by many people (at the same time)!   

Read more about the different app types [here](https://docs.viktor.ai/docs/create-apps/app-types/). 

## Apps Gallery 

We've already added a couple of public apps to the [Apps Gallery](https://www.viktor.ai/apps-gallery/category/all/1) on our website. If you're looking for inspiration to start new projects, this is a great place to explore, try, and share app templates and the accompanying source code with a wide audience.   

**Your app in the gallery?** 

We'd love to fill the Apps Gallery with awesome apps from the community that can be used as inspiration for other VIKTOR users.  

Please let us know if you are interested in showcasing your work in the gallery by sending an e-mail to support@viktor.ai. 

visual svg.svg

You can now publish your apps for free and share them with anyone you want, even people without a VIKTOR account.

Publish & share awesome engineering apps for free!

Finally everyone can publish & share awesome engineering apps for free!

Tutorials

There is potential room for improvement:

1. Create multiple boreholes in a single table.
2. Assign soil properties to each layer automatically.
3. Capability to use repeated soil properties. Of course, this can also be achieved with PLAXIS built-in “.matXdb” to store material database. However, Excel format allows more flexibility to change material properties as per project, as well as having the possibility to link to another master spreadsheet.

This tutorial aims to extend the lesson learned from the 4th tutorial. We will further develop our Excel interface to define soil profiles and assign soil properties in PLAXIS.

1. Read values from Excel using Pandas
2. Input soil depth with Excel and create soil profile
3. Input soil properties with Excel and assign material

As before, this tutorial requires the readers have VS Code and PLAXIS environment installed. If you have not, follow the instructions in the blog [Start Using Python to Automate PLAXIS](https://www.viktor.ai/blog/88/start-using-python-to-automate-plaxis)

Also, we will also need *pandas* installed to the PLAXIS environment. If you haven’t done so, follow the instructions in the blog [PLAXIS output visualization using Python](https://www.viktor.ai/blog/90/plaxis-output-visualization-using-python)

large_Group 167.png

medium_Group 167.png

small_Group 167.png

thumbnail_Group 167.png

Group 167.png

Automate your PLAXIS workflows to build soil profiles and assign correct soil properties.

Automate Soil Profiles in PLAXIS Using Python

Similar to the 4th tutorial, we want to create an Excel input template and create soil profiles in PLAXIS.

We will create an empty excel spreadsheet, call it “Soil_input”. The interface contains two worksheets:

- OHE Ground Profile
- Soil properties

![excel tabs.jpg](https://cms.viktor.ai/uploads/excel_tabs_96cb653361.jpg)

When you create the worksheets, ensure they follow the same names as shown above as the naming is case-sensitive.

## OHE Ground Profile

The purpose of the “OHE Ground Profile” worksheet is to define the name and depth of soil units. These values will be used to create corresponding boreholes in PLAXIS. It involves four input values as shown below:

1. Name: specify the name of each borehole. This row will not be extracted in Python but it’s a good tracker of which boreholes we are working on. For example, column B contains all the input values for “BH1”.
 
2. x coord: define the x coordinate of each borehole.
 
3. Top: define the y coordinate at the top of each borehole. In other words, the top R.L. in terms of geotechnical engineering.
 
4. Soil unit name & layer coordinates: starting from row 4, we will first define the name of soil unit name in column A. Then we input the bottom y coordinate of each unit under each borehole.

It should be emphasised that this template is designed to input the bottom coordinate of each unit. Another important note is that we should input all the units across all the boreholes in column A. Similar to the logic of PLAXIS interface, if we encounter a unit which doesn’t exist in a borehole, we put the same y coordinate as the previous unit.

Take “BH1” as an example, we put 4 m for both “SSIV” and “SSIII”, which means “SSIII” doesn’t exist in “BH1”.

![excel2.webp](https://cms.viktor.ai/uploads/excel2_7204d858e7.webp)

## Soil properties

The purpose of this worksheet is to define the soil properties of each unit. This contains the following columns:

- Name
- Material
- Unit weight (kN/m3)
- Young’s Modulus, E’ (kPa)
- Poisson ratio, v (nu) (-)
- Cohesion, c’ (kPa)
- Friction angle, phi (degree)
- Tensile strength (kPa)
- Interface strength (-)
- K0 auto?: T/F which determines if K0 is calculated automatically in PLAXIS
- K0x = K0y?: T/F to determine if K0x is equivalent to K0y
- K0x (-)
- K0y(-)

![excel3.webp](https://cms.viktor.ai/uploads/excel3_e866b09e00.webp)

These are typical material properties for Mohr-Coulomb model in PLAXIS 2D, just to ensure all input properties are in the correct unit. It should also be noted that this template is only designed for **Drained** condition.

Make sure you have created the excel spreadsheet with the worksheets and values as outlined above.

Once the input file is created, we are ready to move to the next step.


Prepare Your Excel Input Interface

The main goal of Step 1 is to set the soil contour and read the excel input template.

First, we create an empty python file and call it “soil_geometry.py”.

## Import Modules and Start Server

Similar to previous tutorial, we will start off by importing relevant modules and start server.

```python
from plxscripting.easy import *
import subprocess, time
import pandas as pd

###############################################
PLAXIS_PATH = r'C:\Program Files\Bentley\Geotechnical\PLAXIS 2D CONNECT Edition V22\\Plaxis2DXInput.exe'  # Specify PLAXIS path on server.
PORT_i = 10000  # Define a port number.
PORT_o = 10001
PASSWORD = 'SxDBR<TYKRAX834~'  # Define a password.
subprocess.Popen([PLAXIS_PATH, f'--AppServerPassword={PASSWORD}', f'--AppServerPort={PORT_i}'], shell=False)  # Start the PLAXIS remote scripting service.
time.sleep(5)  # Wait for PLAXIS to boot before sending commands to the scripting service.

# Start the scripting server.
s_i, g_i = new_server('localhost', PORT_i, password=PASSWORD)
s_o, g_o = new_server('localhost', PORT_o, password=PASSWORD)

s_i.new()

g_i.SoilContour.initializerectangular(-15, -10, 15, 10)
```

##Read Excel File

File location: C:\Users\phtsang\Desktop\PLAXIS_V22\Python_automation

File name: spreadsheet we created earlier which is “Soil_input.xlsx”

Since we want to extract values from “OHE Ground Profile”, we will use “pd.read_excel()” and specify the worksheet we want to read using “sheet_name”.

```python
source=r"C:\Users\phtsang\Desktop\PLAXIS_V22\Python_automation"
file="Soil_input"+".xlsx"
soilsheet="OHE Ground Profile"
```

Once we have the Excel template set up, we can then use these values to create soil profile.

Step 1: Read Values from Excel Using Pandas

In Step 2, we will extract the borehole values from the “OHE Ground Profile” worksheet and create soil profile accordingly.

The information involved in the input table is shown below. We will need this to reference our code.

![excel4.webp](https://cms.viktor.ai/uploads/excel4_6b2c13b035.webp)

We will be using **pandas**‘s methods to extract values from Excel. Detailed explanation can be found in the blog [PLAXIS output visualization using Python](https://www.viktor.ai/blog/90/plaxis-output-visualization-using-python).

First, we need to extract values from “OHE Ground Profile” worksheet and stores as “df_soil”.

```python
#Soil
df_soil = pd.read_excel(file, sheet_name = soilsheet,engine="openpyxl")
```

Then, we need to create the 1st borehole with the X coordinate from the “BH1” column (i.e. df_soil.iloc[0,1]). It should be noted that the first row is skipped from dataframe.

```python
g_i.borehole(df_soil.iloc[0,1]) # Create borehole at x coord
```

Create the first soil layer using PLAXIS command ‘g_i.soillayer(0)’

```python
g_i.soillayer(0) # Create first layer in 1st borehole
```

After that, we will set the top y coordinate of 1st borehole using the command as shown below.

Soillayers[0]: represents the first soil layer. Soillayers[1] will then represent the second layer etc.

Zones[0]: represents the 1st borehole.

Top.set: allows us to specify the top y coordinate of the soil unit. This only needs to be set once for the first layer as the following layers will automatically take the bottom y coordinate from previous layer as their top y coordinate (similar to what PLAXIS does).

```python
g_i.Soillayers[0].Zones[0].Top.set(df_soil.iloc[1,1]) # Set top y coord of 1st Bh
```

Next, we loop through other borehole columns (i.e. BH2–4) to (1) create boreholes with the given x coordinates and (2) set top y coordinates.

```python
for j in range(len(df_soil.columns)-2):
    g_i.borehole(df_soil.iloc[0,j+2]) # X coord for other Bhs
    g_i.Soillayers[0].Zones[j+1].Top.set(df_soil.iloc[1,j+2]) #Top y coord for other Bhs
```
Once we set the top coordinate of each borehole, we then loop through the rest of the layers and set the corresponding bottom coordinates for 1st borehole.

Here we need to check if the loop reaches the last layer. If we don’t reach the last layer, need to create a new layer using the command ‘g_i.soillayer(1)’, otherwise, don’t create a new layer.

```python
for i in range(df_soil.count()[0]-2): # Loop through the number of layers
    if i == df_soil.count()[0]-3: # Don't create new layer if we are at last unit
        g_i.Soillayers[i].Zones[0].Bottom.set(df_soil.iloc[i+2,1]) #Set bottom y coord for 1st Bh
    else:
        g_i.soillayer(1) #Create new layer if we aren't at last unit
        g_i.Soillayers[i].Zones[0].Bottom.set(df_soil.iloc[i+2,1])
```

Lastly, we loop through the rest of the boreholes except 1st borehole and set the bottom coordinates with the following code.

```python
for j in range(len(df_soil.columns)-2):
    for i in range(df_soil.count()[0]-2):
        g_i.Soillayers[i].Zones[j+1].Bottom.set(df_soil.iloc[i+2,j+2]) #Set bottom y coord for other Bhs
```

The final script should be as follow:

```python
df_soil = pd.read_excel(file, sheet_name = soilsheet,engine="openpyxl")

g_i.borehole(df_soil.iloc[0,1])
g_i.soillayer(0)
g_i.Soillayers[0].Zones[0].Top.set(df_soil.iloc[1,1])
for j in range(len(df_soil.columns)-2):
    g_i.borehole(df_soil.iloc[0,j+2])
    g_i.Soillayers[0].Zones[j+1].Top.set(df_soil.iloc[1,j+2])

for i in range(df_soil.count()[0]-2):
    if i == df_soil.count()[0]-3:
        g_i.Soillayers[i].Zones[0].Bottom.set(df_soil.iloc[i+2,1])
    else:
        g_i.soillayer(1)
        g_i.Soillayers[i].Zones[0].Bottom.set(df_soil.iloc[i+2,1])

for j in range(len(df_soil.columns)-2):
    for i in range(df_soil.count()[0]-2):
        g_i.Soillayers[i].Zones[j+1].Bottom.set(df_soil.iloc[i+2,j+2])
```

Once the soil profile is created, we can then define the soil properties for each soil unit.



Step 2: Input soil depth with Excel and create soil profile

In Step 3, we aim to extract the soi properties from the “Soil properties” worksheet and assign these properties to the layer object (i.e. “SZ”, “SSIV” etc) we specified in column A in the previous section.

The information involved in the input table is shown below.

![excel table artikel philip.png](https://cms.viktor.ai/uploads/excel_table_artikel_philip_7b45aeba64.png)

- Similar to the previous step, we first read the values from “Soil properties” and store them as data frame.

```python
soilmatsheet="Soil properties"
df_soilmat = pd.read_excel(file, sheet_name = soilmatsheet,engine="openpyxl")
```

- The typical soil properties for Mohr-Coulomb model are mentioned under “Excel Input Interface”. We will loop through the rows in the table and use iloc to find each value and assign them to corresponding variables.

- To access soil models in PLAXIS using Python, numerical value should be used which is in the order displayed in PLAXIS. For example, the “Linear Elastic” model is represented by 1 and the “Mohr-Coulomb” model is represented by 2, and so forth and so on.

```python
for i in range(df_soilmat.count()[0]):
    name = df_soilmat.iloc[i,1]

    if df_soilmat.iloc[i,2] == 'MC':
        materialmodel=2

    gammaUnsat=df_soilmat.iloc[i,3]
    gammaSat=df_soilmat.iloc[i,3]
    Eref=df_soilmat.iloc[i,4]
    nu=df_soilmat.iloc[i,5]
    cref=df_soilmat.iloc[i,6]
    phi= df_soilmat.iloc[i,7]
    TensileStrength=df_soilmat.iloc[i,8]
```

- Then, we will assign an interface strength ratio if a value is given in the Excel template. To do this, we need to assign “Manual” as a string to ‘InterfaceStrength’ and the given ratio to ‘Rinter’. If no value is provided, “Rigid” will be assigned to ‘InterfaceStrength’ automatically.

```python
if df_soilmat.iloc[i,9] >0:
        InterfaceStrength = 'Manual'
        Rinter=df_soilmat.iloc[i,9]
    else:
        InterfaceStrength = 'Rigid'
```

- Last component of the soil properties is the K0 condition. We need to decide if the K0 determination is “Manual” or “Automatic”. In PLAXIS-Python environment, “Automatic” and “Manual” are represented by 0 and 1 respectively.

- We will also need to check if K0x = K0y based on user input. The checked and unchecked box of “K0x = K0y” are represented by True and False in Python respectively.

```python
  if df_soilmat.iloc[i,10] =='F':
        K0Determination=1
        if df_soilmat.iloc[i,11] == 'T':
            K0PrimaryIsK0Secondary=True
            K0Primary=df_soilmat.iloc[i,12]
            K0Secondary=df_soilmat.iloc[i,12]
        else:
            K0PrimaryIsK0Secondary=False
            K0Primary=df_soilmat.iloc[i,12]
            K0Secondary=df_soilmat.iloc[i,13]
    else:
        K0Determination=0
```

- Then, use PLAXIS command ‘setproperties()’ to set material properties, similar to the 4th tutorial.

```python
    material1 = g_i.soilmat()
    material1.setproperties(
        "Identification",name,
        "SoilModel",materialmodel,
        "gammaUnsat", gammaUnsat,
        "gammaSat", gammaSat,
        "Eref",Eref,
        "nu", nu,
        "cref", cref,
        "phi", phi,
        "TensileStrength",TensileStrength,
        "InterfaceStrengthDetermination",InterfaceStrength,
        "Rinter",Rinter,
        "K0Determination",K0Determination,
        "K0PrimaryIsK0Secondary",K0PrimaryIsK0Secondary,
        "K0Primary",K0Primary,
        "K0Secondary",K0Secondary
    )
```

- After that, we store the soil material as objects to ‘soilmat’.

```python
soilmat=[mat for mat in g_i.Materials[:] if mat.TypeName.value == 'SoilMat']
```

- Last step is to set material to the soil layer according to the “Name” column (i.e. column A) in the “OHE Ground Profile” worksheet. We will need to use if to check the material name provided in the table. If the name of the material matches the existing material object, assign that material to the soil layer using ‘Soils.setmaterial()’.

```python
for j in range(df_soil.count()[0]-2):
    for i in range(len(soilmat)):
        if df_soil.iloc[j+2,0] == soilmat[i].Name:
            g_i.Soils[j].setmaterial(soilmat[i])
```

The final script is shown below:

```python
soilmatsheet="Soil properties"
df_soilmat = pd.read_excel(file, sheet_name = soilmatsheet,engine="openpyxl")

for i in range(df_soilmat.count()[0]):
    name = df_soilmat.iloc[i,1]

    if df_soilmat.iloc[i,2] == 'MC':
        materialmodel=2


    gammaUnsat=df_soilmat.iloc[i,3]
    gammaSat=df_soilmat.iloc[i,3]
    Eref=df_soilmat.iloc[i,4]
    nu=df_soilmat.iloc[i,5]
    cref=df_soilmat.iloc[i,6]
    phi= df_soilmat.iloc[i,7]
    TensileStrength=df_soilmat.iloc[i,8]

    if df_soilmat.iloc[i,9] >0:
        InterfaceStrength = 'Manual'
        Rinter=df_soilmat.iloc[i,9]
    else:
        InterfaceStrength = 'Rigid'

    if df_soilmat.iloc[i,10] =='F':
        K0Determination=1
        if df_soilmat.iloc[i,11] == 'T':
            K0PrimaryIsK0Secondary=True
            K0Primary=df_soilmat.iloc[i,12]
            K0Secondary=df_soilmat.iloc[i,12]
        else:
            K0PrimaryIsK0Secondary=False
            K0Primary=df_soilmat.iloc[i,12]
            K0Secondary=df_soilmat.iloc[i,13]
    else:
        K0Determination=0

    material1 = g_i.soilmat()
    material1.setproperties(
        "Identification",name,
        "SoilModel",materialmodel,
        "gammaUnsat", gammaUnsat,
        "gammaSat", gammaSat,
        "Eref",Eref,
        "nu", nu,
        "cref", cref,
        "phi", phi,
        "TensileStrength",TensileStrength,
        "InterfaceStrengthDetermination",InterfaceStrength,
        "Rinter",Rinter,
        "K0Determination",K0Determination,
        "K0PrimaryIsK0Secondary",K0PrimaryIsK0Secondary,
        "K0Primary",K0Primary,
        "K0Secondary",K0Secondary
    )

soilmat=[mat for mat in g_i.Materials[:] if mat.TypeName.value == 'SoilMat']

for j in range(df_soil.count()[0]-2):
    for i in range(len(soilmat)):
        if df_soil.iloc[j+2,0] == soilmat[i].Name:
            g_i.Soils[j].setmaterial(soilmat[i])
```

Run the script with the following:

```python
(PLAXIS) C:\Users\phtsang\Desktop\PLAXIS_V22\Python_automation>python soil_geometry.py
```

You should see the following is created in PLAXIS 2D. As you see from the soil windows, all boreholes have been created according the inputs from Excel.


![PLAXIS GIF.gif](https://cms.viktor.ai/uploads/PLAXIS_GIF_d64deb774a.gif)

</br>

![PLAXIS screenshot.png](https://cms.viktor.ai/uploads/PLAXIS_screenshot_208d6a8363.png)

</br>

In terms of soil properties, all soil units have been created with the properties we specified in the input table.

![PLAXIS screenshot 2.png](https://cms.viktor.ai/uploads/PLAXIS_screenshot_2_27ed8cb435.png)

</br>

Brilliant! We have just created a soil profile with material definition using a user interface for PLAXIS 2D.

Step 3: Input soil properties with Excel and assign material

That’s all for the fifth tutorial on creating soil profiles including material definitions using Python. After this tutorial, you should be able to obtain soil input from excel and create profile, as well as assign soil properties in PLAXIS.

Here you can find all tutorials to keep improving your automation skills:

[Tutorial 1: Start Using Python to Automate PLAX ](https://www.viktor.ai/blog/88/start-using-python-to-automate-plaxis)

[Tutorial 2: Extract PLAXIS results automatically using Python](https://www.viktor.ai/blog/89/automatically-extract-plaxis-output-with-python)

[Tutorial 3: PLAXIS result visualization using Python ](https://www.viktor.ai/blog/90/plaxis-result-visualization-using-python)

[Tutorial 4: Create a PLAXIS model based on a Excel sheet using Python](https://www.viktor.ai/blog/92/create-a-plaxis-model-based-on-a-excel-sheet-using-python)

[Tutorial 5: Can the AI chatbot ChatGPT do geotechnical engineering?](https://www.viktor.ai/blog/91/ai-chatGRP-geotechnical-engineering)

If you're interested in hearing more about Python, PLAXIS and workflow automation, feel free to follow [my LinkedIn page](https://www.linkedin.com/in/philip-chin-fung-tsang-207a8b92/). You can also support me by following me on [Medium](https://medium.com/@philip.studio11) where I will provide source code and more general programming techniques in the future.

What's next?

## Introduction

Welcome to this tutorial on setting up an Image Classification Convolution Neural Network within a VIKTOR app. The VIKTOR platform is a powerful tool for deploying and managing machine learning models, and in this tutorial, we will be showing you how to set up a pre-trained image classification model within a VIKTOR app. Although this tutorial will not focus on the training of the model, we will briefly mention the steps required to train the model on the CIFAR-10 dataset, an image dataset containing 10 classes of various objects such as airplanes, cars, and birds. Using TensorFlow, an open-source machine learning library, to build and train the model.

[![machine learning classification app](https://cms.viktor.ai/uploads/image_recognition_app_28acccc54e.svg)](https://demo.viktor.ai/public/image-classification)

By the end of this tutorial, you will have a working image classification model deployed within a VIKTOR app, and be able to use the model to classify images in real-time. This tutorial is perfect for engineers and developers who want to use pre-trained models to add image classification functionality to their projects.

Let's get started!


## Step 1: Install VIKTOR

For one to be able to develop a VIKTOR app, you need a VIKTOR developer account. If you do not have one yet, visit the 
["Start building apps"](https://www.viktor.ai/start-building-apps) page on the VIKTOR website and follow the 
instructions.

In case you are new to VIKTOR, it is recommended to also follow the [build your first app tutorial](https://docs.viktor.ai/docs/getting-started/create-first-app) before you continue with this tutorial.

## Step 2: Train the image recognition neutral network (Optional)

This step is optional, as the tutorial focuses on implementing a pre-trained image classification model.

You can find all the files needed for this tutorial, including the pre-trained models, in the [cnn_model folder](https://github.com/viktor-platform/sample-image-classification-app/tree/main/cnn_model). So, you can skip to the next step if you want. Note we generated the models using TensorFlow 2.11.0

In case you are interested in developing a model yourself, follow the instructions in this [GeeksforGeeks article](https://www.geeksforgeeks.org/cifar-10-image-classification-in-tensorflow/), on which this tutorial is based.

Just to give you an overview,  we made and trained the model in the following way:

1. Install TensorFlow locally in our machine using `pip install tensorflow`

2. Get [CIFAR-10 dataset](https://www.cs.toronto.edu/~kriz/cifar.html) to train the model. The CIFAR-10 dataset consists of 60.000 32x32 colour images in 10 classes: Airplane, Automobile, Bird, Cat, Deer, Dog, Frog, Horse, Ship, Truck. 

2. Create a Convolution Neural Network (CNN) with 32x32 pixels as the input layer and the 10 classes as the output layer.

4. Train the model using the CIFAR-10 dataset. Use at least 10 epochs to improve the accuracy of the model.
 
4. Save the trained model as a .h5 file. You will use this file in the app.


If you are going train the model yourself, **It is strongly advised to run this locally and not in a VIKTOR environment, as it can be time-consuming**

You can use the code example [train your image recognition convoluted neural network](https://github.com/viktor-platform/sample-image-classification-app/blob/main/cnn_model/cnn_cifar10_example.py) to generate your own models.



## Step 3: Create an app using your trained convoluted neural network

Now, with a machine-learning model available, you can now set up your application.

- Create a new (editor-type) app template. In your terminal, write `viktor-cli create-app image-recognition-app --app-type editor`
- Add `tensorflow-cpu==2.11.0` to the `requirements.txt`
- Add .h5 model files to your app folder
- In your parametrization, add `FileField` that allows the uploading of JPEG/JPG/PNG images
- If you use multiple models, add an `OptionField` to your parametrization, allowing users to select different models

Here is some example code:

```python
MODEL_OPTIONS = [
    OptionListElement(label="CNN (2 epochs)", value="cnn_cifar10_model_2_epochs.h5"),
    OptionListElement(label="CNN (5 epochs)", value="cnn_cifar10_model_5_epochs.h5"),
    OptionListElement(label="CNN (10 epochs)", value="cnn_cifar10_model_10_epochs.h5"),
]


class Parametrization(ViktorParametrization):
    image = FileField("Upload a JPEG/JPG or PNG image", file_types=[".jpeg", ".jpg", ".png"])
    model = OptionField("Select CNN model", options=MODEL_OPTIONS, default=MODEL_OPTIONS[0].value)
```


- Write a function that preprocesses the uploaded image to tensor: normalize the RGB values and resize to (32, 32) pixels. 
Use `tf.image` functionalities to do this. Finish with `img = tf.expand_dims(img, axis=0)` in your conversion to align the dimensions of your image and the model.

```python
def preprocess_image(unclassified_image_bytes: bytes):
    img = tf.image.decode_jpeg(unclassified_image_bytes, channels=3)
    img = tf.cast(img, tf.float32)
    img = img / 255.0  # normalize RGB values
    size = (32, 32)  # size depending on size used in model, trained model is 32 x 32 pixels
    img = tf.image.resize(img, size)
    img = tf.expand_dims(img, axis=0)  # expand dimensions of tensor
    return img
```

- Create a `ImageAndDataView` to show the results (upload image and predicted classes + probabilities for example) within the Controller. 
- Define the logic to load the model and predict the uploaded images using the `model.predict()` with the preprocessed 
image tensor as input to predict the class:

```python
CLASSES = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]

...
class Controller(ViktorController):
    ...

    @ImageAndDataView("Image", duration_guess=3)
    def visualize_image_and_show_classification_results(self, params: Munch, **kwargs) -> ImageAndDataResult:
        # Load model
        model = tf.keras.models.load_model(params["model"])
    
        # Preprocess uploaded image
        unclassified_image_tensor = preprocess_image(params.image.file.getvalue_binary())
    
        # Predict
        pred = model.predict(unclassified_image_tensor)
        results = [(class_name, prob) for class_name, prob in sorted(zip(CLASSES, pred.tolist()[0]), key=lambda x: x[1], reverse=True)]
    
        # Generate results
        data = [DataItem(label=class_name.title(), value=prob * 100, suffix="%", number_of_decimals=2) for class_name, prob in results]
        return ImageAndDataResult(image=params.image.file, data=DataGroup(*data))
```
- Find some JPEGS/JPG/PNG images online and test it out!

**Congratulations, you are now able to deploy a locally trained Image Classification model!**

## How could this be used in practice?

Computer vision and image recognition can be used to help engineers in a variety of ways, such as:
- Quality control: Engineers can use image recognition to inspect products for defects, such as scratches or cracks, 
during the manufacturing process, or to check diagrams for errors or anomalies.
- Inspection: Engineers can use computer vision to inspect infrastructure, such as bridges or pipelines, for signs of 
wear or damage.
- Medical imaging: Engineers can use image recognition to improve the diagnostic accuracy of medical imaging systems 
such as x-ray, CT, and MRI.
- Smart agriculture: Engineers can use computer vision to monitor crop growth, detect pests, and make decisions about 
irrigation, fertilization, and harvesting


large_image recognition (2).jpg

medium_image recognition (2).jpg

small_image recognition (2).jpg

thumbnail_image recognition (2).jpg

image recognition (2).jpg

In this tutorial, you will learn how to turn an image classification neural network model into a  user-friendly app.

image-recognition-app-CIFAR-10 dataset

Tutorial: Build an image classification app

## Improved input validation

We have improved the input validation on multiple parts! See how you can block actions on invalid fields, mark fields as invalid, and easily validate steps. 

### Block actions on invalid fields

In the future, limitations you already annotated (like min/max) will block the user from performing any subsequent actions (such as clicking a button, generating a view, or moving to the next step). Learn how you can activate this now in the [documentation](https://docs.viktor.ai/docs/create-apps/user-input/input-validation/#generic-field-constraints).

### Mark fields as invalid

When you are performing input validation, you can mark fields as invalid. This makes it a lot easier for users to correct mistakes. Visit the [documentation](https://docs.viktor.ai/docs/create-apps/user-input/input-validation/#specific-input-validation) to learn more about this feature.

### Step validation

Enable validation code to prevent users from moving to the next step in case their input is not valid. Visit the [documentation](https://docs.viktor.ai/docs/create-apps/layout-and-styling/steps/#validation-of-user-input) for more information on how to enable step validation.

![step_validation2.png](https://cms.viktor.ai/uploads/step_validation2_9bccc480e0.png)

</br>

## Seamless developer onboarding

We have created a new and seamless onboarding experience in which developers are guided through all the necessary steps to start building apps. In only 5 minutes, you can install VIKTOR and start the demo application!
 
If you haven't installed VIKTOR yet, do not hesitate any longer and log in to [get started](https://docs.viktor.ai/docs/getting-started/).

![Seamless onboarding.gif](https://cms.viktor.ai/uploads/Seamless_onboarding_37a9ef025e.gif)

</br>

## View developer statistics in the activity dashboard

To give better insight into the adoption of VIKTOR within your company, we have added the activity of the developers to the activity dashboard. Here you can find data on the number of developers and how often they log in. 

![Activity Dashboard.png](https://cms.viktor.ai/uploads/Activity_Dashboard_aa77c41d46.png)

</br>

## Other changes

**SDK**

- SDK version 13.7.0 is now available

</br>

**PLATFORM**
- Fixed the file field upload button to be disabled when the editor is locked 
- Fixed that users no longer only have read access on editor-type apps 
- Fixed map view crash when trying to zoom in while already at max zoom level after view load 
- Removed development workspaces from workspaces activity dashboard 
- Fixed that app version manifest are assigned to new workspaces 
- Fixed possible app type mismatch for new app versions 
- Added missing dutch translation on the admin page 
- Custom marker size supported in ```GeoJSONView```
- Daily active users (per day/week/month) calculation based on workspace usage instead of logins on the environment
- Map tile and image provider switched to ESRI

</br>

**WORKER**

- Worker version 5.3.1 is now available 
- Fixed bug where Excel worker raised an error when a timeout was encountered 

</br>

**CLI**

- CLI version 0.26.1 is now available
- Added get-started command for new onboarding flow
- Added support for Python installed through Windows App Store 


large_Newsletter img (2).jpg

medium_Newsletter img (2).jpg

small_Newsletter img (2).jpg

thumbnail_Newsletter img (2).jpg

Newsletter img (2).jpg

Improved input validation, seamless developer onboarding, and track developer in the activity dashboard.

What's new in VIKTOR (January 2023)

## Archive your workspaces

Besides creating workspaces yourself, administrators can now also archive old workspaces that are no longer being used.

Archiving a workspace removes it from the workspaces overview, ensuring other users can no longer view or access it. This makes it easier to navigate the list of workspaces that are still in use. Data from an archived workspace will not get deleted. You can always unarchive an already archived workspace.

![archive workspaces.png](https://cms.viktor.ai/uploads/archive_workspaces_959170a48f.png)

</br>

## Publish & share your apps for free


Maybe you have already heard it, but we have some exciting news for the community! From now on, free users can publish and share editor-type apps with anyone they want. This means besides developing apps, you can now also experience how easy it is to share your apps with end-users.

This new feature gives a big boost to our community, enabling all developers to share their creations with the world and providing the opportunity to test and learn from each other's work. 

We are very much looking forward to seeing all the awesome apps from the community being shared. If you want to share your app with a wide audience, we would love to help you out by adding your app to our [Apps Gallery](https://www.viktor.ai/apps-gallery/category/all/1) and promoting it through our network. Let us know by sending a mail to support@viktor.ai.

![share solar panel app.jpg](https://cms.viktor.ai/uploads/share_solar_panel_app_9b378dff36.jpg)

</br>

[![CTA_Join the community](https://cms.viktor.ai/uploads/CTA_Join_the_community_22d97b332e.svg)](https://community.viktor.ai/)

</br>


## View historical jobs in the job log

We are introducing the job log: a new feature in which the results of the last 5 historical jobs are shown. The job log contains details on the starting time of the job, when it was completed, and whether it was successful or not. This allows you to report problems on old non-successful jobs.

![icons 2.png](https://cms.viktor.ai/uploads/icons_2_5745764ac9.png)
![job_log.png](https://cms.viktor.ai/uploads/job_log_ef8293da13.png)

</br>

## Other changes

**SDK**

- SDK version 13.8.0 is now available

**PLATFORM**

- Fixed text not wrapping properly in map popups 
- Fix that workspace-admin can now also rename workspace 

**CLI**

- CLI v0.29.0 is now available 
- Added SDK version to output of ‘apps’ command 
- Added app type, SDK version and python version to output of ‘describe’ command 
- Updated the ‘install’ command to use additional environment variables during installation 
- Support for defining VIKTOR Python dependency in requirements.txt without a leading hashtag- Improved help 'create-app' command
- Bugfix for reload not working for app folder names  starting with "test"

Newsletter img (5).svg

Archiving of workspaces, an overview of historical jobs in the job log, and free publishing & sharing of your apps!

VIKTOR Blog

What's new in VIKTOR? (February 2023)