Script Example - Creo Mapkey Os
Here are copy-paste ready examples to add to your config.pro.
Purpose: Creates a new drawing, sets format, adds general view, and sets scale.
! Mapkey for creating a standard drawing
mapkey dwg @MAPKEY_LABELNew Drawing;\
mapkey(continued) ~ Command `ProCmdDrawingNew` ;\
mapkey(continued) ~ Input `new_dwg` `InputOpt` `A4_LANDSCAPE`;\
mapkey(continued) ~ Command `ProCmdDwgNewFromSel` ;\
mapkey(continued) ~ Select `main_dlg_cur` `PH_left_assist` 1 `dwg_ftab`;\
mapkey(continued) ~ Activate `dwg_ftab` `FormatBrowseBtn`;\
mapkey(continued) ~ Select `file_open` `Ph_list_Filelist` 1 `c_frm_a4.frm`;\
mapkey(continued) ~ Activate `file_open` `Open`;\
mapkey(continued) ~ Activate `dwg_ftab` `OK`;\
mapkey(continued) ~ Command `ProCmdDwgViewCreate` 1;\
mapkey(continued) ~ Command `ProCmdDwgViewOrientation` `general`;\
mapkey(continued) ~ Activate `dwg_create_view` `PickPB`;\
mapkey(continued) ~ Command `ProCmdDwgViewScale` ;\
mapkey(continued) ~ Input `dwg_view_scale` `InputOpt` `1`;\
mapkey(continued) ~ Activate `dwg_view_scale` `Accept`;
When Creo launches a script, the "Current Working Directory" is NOT your Creo session directory. It is often C:\Program Files\PTC\Creo X.0\bin\.
Fix: Always use absolute paths in your scripts (e.g., C:\Logs\ instead of Logs\). Or, at the top of your batch script, add cd /d "%~dp1" to change to the directory of the file Creo passed.
You cannot run OS_Script delete_temp_files.bat and immediately OS_Script erase current.prt in the same Mapkey. The first script might still be running when the second starts.
Fix: Use !OS_Script (sequential) or merge your logic into a single master script.
Would you like a specific automation scenario (export PDF, save as STEP, batch open drawings, etc.)?
A creo mapkey os script example is more than a code snippet—it is the gateway to professional-grade CAD automation. By offloading file management, conditional logic, and external application control to Batch or PowerShell scripts, you transform Creo from a standalone modeling tool into a node in your company's digital thread.
Your next step: Pick one repetitive task you hate (e.g., "Save a STEP file and email it to the vendor"). Write a 5-line batch script to handle the file move. Create a Mapkey that runs the export and calls the script. You will reclaim hours each month.
This article is practical for Creo Parametric 7.0 and above. Syntax may vary slightly for Creo Elements/Direct, but the OS_Script command remains consistent.
OS Script mapkey in PTC Creo Parametric allows you to execute external operating system commands (like batch files, Python scripts, or PowerShell) directly from within the Creo environment. Example Syntax You can define an OS Script mapkey manually in your config.pro (or the newer mapkeys.profile in Creo 11) using the PTC Community Code Example:
mapkey run_py @MAPKEY_NAMEExecute Python Script;@MAPKEY_LABELPyScript;\ mapkey(continued) @SYSTEMpython "C:\scripts\my_creo_automation.py"; Use code with caution. Copied to clipboard How to Create via the UI Instead of manual coding, you can use the OS Script tab in the Mapkeys dialog: Mapkeys Settings and enter your desired shortcut (e.g., Navigate to the tab in the Record Mapkey dialog. Type the command you want the OS to run (e.g., C:\temp\cleanup.bat , then immediately click
Save your changes to your configuration file to keep the mapkey for future sessions. Why use OS Scripts? Automation:
Launch batch files that clean up temporary files in your working directory. External Integration:
Open a project tracker or specific network folder related to the active model. Background Tasks:
Run complex data exports or manipulations using Python or VB API without leaving the Creo window. PTC Community Solved: Script - PTC Community
In the world of , Mapkeys are the ultimate productivity hack, allowing you to record a series of mouse clicks and keyboard commands into a single shortcut. However, the real magic happens when you use the @SYSTEM command to trigger OS Scripts (batch files or shell scripts) directly from within your CAD environment.
Below is a draft blog post designed to help your readers bridge the gap between Creo commands and operating system automation. Supercharging Creo: How to Use Mapkeys with OS Scripts
If you’ve been using PTC Creo for a while, you probably have a library of Mapkeys for common tasks like changing view orientations or toggling datums. But what happens when you need to do something outside of Creo—like moving a file, launching a specific spreadsheet, or triggering a custom Python script?
That’s where OS Scripting in Mapkeys comes in. By using the @SYSTEM command, you can turn Creo into a control center for your entire engineering workflow. What is a Creo OS Script Mapkey?
Standard Mapkeys record internal Creo commands. An OS Script Mapkey, however, sends a command directly to your Windows Command Prompt (CMD) or Linux Shell. This allows you to automate file management, sync with PDM systems, or open third-party analysis tools without leaving your workspace. Step-by-Step: Creating an OS Script Mapkey
You can manually edit your config.pro file to add these powerful shortcuts. Here is the syntax for a basic example that opens a specific project folder in Windows Explorer. The Script Example Add this line to your config.pro:
mapkey .expl @MAPKEY_LABELOpen Project Folder;\ mapkey(continued) @SYSTEMstart explorer.exe "C:\Projects\Current_Job"; Use code with caution. Copied to clipboard Breakdown of the Code:
mapkey .expl: This defines the shortcut (typing .expl in Creo triggers the action).
@MAPKEY_LABEL: Provides a name for the command in the Mapkey dialog.
@SYSTEM: This is the critical "bridge" command. It tells Creo: "Stop looking at CAD commands and send the following text to the Operating System."
start explorer.exe...: This is the standard Windows command to open a folder. Practical Use Cases
Why bother with this? Here are three ways professional power users use OS Scripts:
Automated Backups: Create a Mapkey that saves your work and then runs a .bat file to copy the latest version to a secure "Archive" folder.
External Calculators: Map a key to launch an Excel-based tolerance stack-up tool or a custom Python script that processes exported CSV data.
Cleanup Tools: Run a script that deletes all old version files (*.1, *.2, etc.) in your working directory to keep your workspace tidy. Pro-Tip: The "Silent" Run
If you don't want a Command Prompt window popping up every time you run your Mapkey, you can call a VBScript or a "hidden" batch file to keep the UI clean.
Mapkeys aren't just for CAD commands anymore. By leveraging the @SYSTEM call, you can automate the "boring stuff" that happens between your design sessions.
Want to dive deeper? Check out the PTC Support Portal for the latest documentation on Mapkey syntax and configuration.
In PTC Creo, Mapkeys are powerful keyboard shortcuts that record a series of UI actions, but their most advanced feature is the ability to run OS Scripts. This allows you to execute commands directly in your operating system (like Windows CMD or Batch files) without leaving the Creo environment. OS Script Mapkey Example
A common use for an OS script is to launch an external tool or perform a file management task. For instance, you can create a mapkey that opens a calculator or copies a configuration file to your working directory.
Basic Syntax in config.pro:To run a command, the mapkey uses the @SYSTEM prefix. Example: Open Windows Calculator mapkey c @SYSTEM start calc.exe; Use code with caution. Copied to clipboard
How it works: When you type c in Creo, it executes the Windows start command to open the calculator. Example: Open Current Working Directory mapkey owd @SYSTEM start explorer . Use code with caution. Copied to clipboard
How it works: This launches Windows Explorer directly to your current Creo working directory. How to Create an OS Script Mapkey
Open the Mapkeys dialog (File > Options > Environment > Mapkey Settings). Click New and define your key sequence (e.g., os). Go to the OS Script tab.
Type your command (e.g., start notepad.exe) into the text area. Click OK and save to your config.pro to make it permanent. Advanced "Interesting" Use Cases creo mapkey os script example
Select a file in assy and run mapkey to "Show file in Windows Explorer"
In Creo Parametric, a mapkey OS script allows you to execute external operating system commands or scripts directly from the Creo environment without minimizing the software window. This feature is commonly used to automate file management, launch external applications, or perform complex data processing that Creo's native macro language cannot handle alone. PTC Community Defining an OS Script Mapkey
To create a mapkey that runs an OS script, follow these steps in the Creo Mapkeys Settings Navigate to File > Options > Mapkeys Settings to open the Record Mapkey dialog. Key Sequence ) and a name/description. Switch to the OS Script tab within the dialog box.
Enter the OS command or the path to your external script in the text area provided. PTC Community Script Examples and Syntax Mapkeys use the
prefix in their configuration code to identify an OS-level command. PTC Community Calling a VBScript or Batch File:
You can point directly to an executable file on your network or local drive.
mapkey(continued) @SYSTEMZ:\\folder\\subfolder\\script.VBS;\ Copied to clipboard PTC Community Discussion File Management (Batch Example):
You can use standard Windows CMD commands to clean up directories or move files.
mapkey(continued) @SYSTEMdel old_config.pro\n\ mapkey(continued) @SYSTEMdir /b *.prt > current_parts.txt\n\ Copied to clipboard PTC Community Writing Tips Launching External Applications:
A common use case is opening a specific customer folder based on the current working directory.
@echo off set cdn=%cd% if exist "\\server\docs\%cdn%" ( start "" "\\server\docs\%cdn%" ) Use code with caution. Copied to clipboard PTC Customization Forum Key Use Cases Config Synchronization:
Automatically copying a standard company configuration file from a central server to your local working directory before loading it into your session. Data Exporting:
Running a script that zips or moves exported PDFs/STEP files to a specific release folder. Workflow Integration:
Triggering third-party PLM or analysis tools that require command-line arguments derived from the active Creo model. PTC Community Configuration Storage Starting with , mapkeys are primarily stored in a dedicated mapkeys.pro file located in the user's
roaming folder, though they can still be manually managed in the config.pro for legacy support. PowerShell
script example that integrates with this mapkey system for advanced file processing? Creo Parametric 11.0 - Mapkeys Configuration File
A Creo Mapkey OS Script allows you to execute external system commands, batch files, or scripts directly from within a Creo Parametric session without minimizing the application. This is achieved using the @SYSTEM directive within your config.pro or mapkeys.pro file. Syntax Overview
The core syntax for calling an external script is:mapkey(continued) @SYSTEM
@SYSTEM: Tells Creo to pass the following text to the operating system's command processor.
Pathing: Use double backslashes (\\) for Windows file paths or single forward slashes (/).
Continuations: Ensure each line ends with a backslash (\) if the mapkey spans multiple lines. 1. Running a Batch File (.bat)
This is the most common method for automating file movements or launching custom enterprise tools.
mapkey run_batch @MAPKEY_LABEL Run Custom Batch; \ mapkey(continued) @SYSTEMC:\\scripts\\my_tool.bat; Use code with caution. Copied to clipboard
Tip: You can use the start command to run the script in a separate window if you don't want Creo to wait for it to finish. 2. Running a VBScript (.vbs)
VBScripts are often used to manipulate the Windows clipboard or send keystrokes back to Creo.
mapkey vbs_copy @MAPKEY_LABEL Copy Part Name; \ mapkey(continued) @SYSTEMWScript.exe C:\\creostart\\vbs\\get_name.vbs; Use code with caution. Copied to clipboard 3. Inline OS Commands
You can also run simple one-line commands like deleting temporary files or opening a network folder.
mapkey open_docs @MAPKEY_LABEL Open Project Folder; \ mapkey(continued) @SYSTEMstart "" "\\server\projects\drawings"; Use code with caution. Copied to clipboard Implementation Tips
Recording via GUI: You can insert OS scripts during creation by going to File > Options > Mapkeys Settings, clicking New, and using the OS Script tab in the Record Mapkey dialog.
Storage: Starting with Creo 11, mapkeys are typically saved in a dedicated mapkeys.pro file rather than config.pro.
Environment Variables: You can use system variables like %temp% or %cd% (current directory) within your scripts to make them more dynamic across different workstations.
Do you need help debugging a specific script or passing variables from Creo to your OS command? To Define a Mapkey - PTC Support Portal
To Define a Mapkey. Fundamentals > User Interface Basics > Working with Mapkey Macros > To Define a Mapkey. To Define a Mapkey. 1.
How to call a external applications using OS script (mapkey)?
Creo Parametric mapkeys are powerful macros that automate repetitive tasks within the software. However, their true potential is unlocked when you integrate OS Scripts (Operating System commands). This allows Creo to interact with your local drive, network servers, and external applications.
Below is a comprehensive guide and example for creating a Creo mapkey that executes an OS script. 🛠️ The Core Concept: ~ Run OS
In a Creo mapkey, the command sequence ~ Run OS tells Creo to pause its internal operations and pass a command string to the Windows shell (cmd.exe). This is the bridge between CAD modeling and system-level automation. Key Syntax Components mapkey: Defines the start of the macro. $F7: The keyboard shortcut (in this example, the F7 key). @SYSTEM: Tells Creo to execute a system-level command.
cmd /c: The Windows command to run a string and then terminate. 📝 Example: Auto-Backup and Zip Workspace Here are copy-paste ready examples to add to your config
This script is a favorite for engineers. It saves the current model, then triggers an OS script to copy the file to a backup folder and compress it. Step 1: Create the Windows Batch File (backup_creo.bat) First, create a simple script on your C:\scripts\ folder.
@echo off set "target=D:\Creo_Backups" if not exist "%target%" mkdir "%target%" copy /y *.prt* "%target%\" echo Backup Complete! pause Use code with caution. Step 2: The Creo Mapkey Example
Add this code to your config.pro file or load it via the Mapkeys dialog.
mapkey f7 @MAPKEY_LABEL Backup to Server;\ mapkey(continued) ~ Command `ProCmdModelSave` ;\ mapkey(continued) @SYSTEMstart /min C:\scripts\backup_creo.bat; Use code with caution. 🔍 Breaking Down the Script 1. Saving the Model
~ Command 'ProCmdModelSave' ;Before running an OS script that interacts with files, you must ensure the latest version is written to the disk. 2. The @SYSTEM Trigger
This is the most critical part. It launches the Windows command processor. 3. The start /min Trick
Using start /min ensures that the black command prompt window opens "minimized." This prevents a jarring pop-up from interrupting your design workflow. 💡 Advanced Use Cases Open Current Working Directory in Explorer
Tired of browsing through folders? This mapkey opens your current Creo working directory in Windows Explorer instantly.
mapkey od @MAPKEY_LABEL Open Dir;\ mapkey(continued) @SYSTEMstart explorer .; Use code with caution. Clean Old Versions (Purge)
While Creo has a purge command, using the OS to run the purge.exe utility is often faster and more reliable for large assemblies.
mapkey pu @MAPKEY_LABEL Purge Versions;\ mapkey(continued) @SYSTEMpurge;\ mapkey(continued) @SYSTEMdel *.inf.* *.log.*; Use code with caution. ⚠️ Best Practices & Troubleshooting
Pathing: Always use absolute paths (e.g., C:\scripts\script.bat). Creo often loses track of relative paths if your working directory changes.
Quotes: If your file paths contain spaces (e.g., Program Files), you must wrap the path in triple quotes within the mapkey: """C:\My Scripts\run.bat""".
Permissions: Ensure the user running Creo has "Execute" permissions for the batch file or Python script being called.
Sync vs Async: By default, Creo waits for the OS script to finish before returning control to the user. Use the start command to run scripts asynchronously if you want to keep working while the script runs in the background.
What specific task are you trying to automate (e.g., PDF export, file renaming, PLM upload)? What version of Creo are you using?
Do you prefer using Batch (.bat) or Python (.py) for your OS scripts?
I can provide the exact code block for your specific workflow.
In Creo Parametric, a mapkey using an OS script allows you to execute operating system commands (like Windows CMD or batch files) directly from within your CAD session. This is a powerful way to automate tasks that Creo cannot do natively, such as managing external files or launching third-party applications. Useful Feature: Automatically Opening the Working Directory
A highly practical use for an OS script mapkey is a "Quick Open Explorer" command. Instead of manually navigating through Windows to find your current project files, this script triggers Windows Explorer to open exactly where you are working in Creo.
Example Mapkey Code:You can add this line to your config.pro (or mapkeys.pro in newer versions) to map the shortcut wd to open your working directory: mapkey wd @SYSTEM start explorer . Use code with caution. Copied to clipboard
@SYSTEM: This prefix tells Creo that the following text is an operating system command rather than a Creo internal command.
start explorer .: This is a standard Windows command where . represents the current folder (your Creo working directory). Other Practical Examples
Launch a Calculator: Use mapkey calc @SYSTEM start calc.exe to quickly bring up a calculator without leaving your workspace.
External File Management: Run a batch file that renames or moves exported PDFs and DXFs to a specific server location immediately after they are generated.
Purge Files: Create a mapkey that runs the purge command in your working directory to delete old iterations and save disk space. Key Benefits of OS Scripts
Non-Interruptive: You can start these scripts without minimizing Creo or switching focus away from your design.
Workflow Integration: They bridge the gap between CAD modeling and your broader file management or simulation pipeline.
Automation of Repetitive Tasks: For instance, you could script a process to copy specific configuration files from a central company directory into your local session. Mapkey Copy & Paste - PTC Community
Master PTC Creo Mapkeys with OS Scripts: A Complete Guide Automating repetitive tasks in PTC Creo often requires going beyond simple button-click recordings. To truly streamline your workflow—like automatically renaming files, moving data to specific folders, or triggering external Python scripts—you need to leverage the power of OS Scripts within Mapkeys.
This guide provides clear examples and best practices for integrating Operating System commands directly into your Creo environment. What is a Creo OS Script Mapkey?
A standard mapkey records internal Creo commands. An OS Script mapkey uses the @SYSTEM syntax to "break out" of Creo and execute commands in the Windows Command Prompt (CMD) or shell environment. The Basic Syntax
In your config.pro file, an OS-based mapkey looks like this: mapkey example @SYSTEMstart notepad.exe; Use code with caution. mapkey: Initiates the definition. example: The shortcut keys you press.
@SYSTEM: Tells Creo to send the following text to the Operating System. ;: Ends the mapkey sequence. Example 1: Open the Current Working Directory
One of the most useful scripts is a "one-touch" button to open the folder where your current files are saved. The Mapkey: mapkey .fod @SYSTEMexplorer . ; Use code with caution.
How it works: explorer . tells Windows to open File Explorer at the current relative path (the dot represents "here").
Why use it: Saves you from navigating through deep server directory trees manually. Example 2: Run a Python Script for Batch Renaming
If you have a Python script that processes exported CSVs or renames STEP files, you can trigger it without leaving the Creo interface. The Mapkey: mapkey .py @SYSTEMpython C:\scripts\process_data.py; Use code with caution. When Creo launches a script, the "Current Working
Pro Tip: Ensure python is in your Windows Environment Path so Creo can find the executable. Example 3: Create a "Purge" Shortcut
Creo creates version numbers for every save (e.g., part.prt.1, part.prt.2). While Creo has a purge command, many users prefer the classic OS-level batch purge. The Mapkey: mapkey .pur @SYSTEMpurge; Use code with caution.
(Note: This requires the PTC purge.exe utility to be in your system path, which is standard in most installations.) Example 4: Advanced Scripting with Arguments
You can chain commands or call complex batch files (.bat or .cmd). This is useful for pushing files to a backup server. The Mapkey: mapkey .bak @SYSTEMC:\scripts\backup_tool.bat; Use code with caution. The backup_tool.bat Content:
@echo off mkdir "C:\Backup\%DATE%" copy *.prt* "C:\Backup\%DATE%\" echo Backup Complete! pause Use code with caution. Critical Tips for Success
Use the Mapkey Editor: While you can type these into config.pro, it is safer to use the Mapkey Dialog in Creo. When recording, choose "OS Script" from the "OS Command" tab.
Avoid Blocking: If you run a script that stays open (like a persistent CMD window), Creo may "freeze" until that window is closed. Use the start command (e.g., @SYSTEMstart cmd) to run the process in the background.
Pathing Issues: If your file paths contain spaces, you must use double quotes. However, because config.pro also uses quotes, you often need to escape them or use a batch file as a middleman.
The "Pause" Command: If your script runs and disappears too fast to see errors, add pause to the end of your .bat file so the window stays open for troubleshooting. Conclusion
Integrating OS scripts into your Creo mapkeys transforms the software from a CAD tool into a fully integrated engineering workstation. Start with a simple folder shortcut and gradually move toward complex automation with Python or Batch scripts.
Creo mapkey OS script is a powerful automation tool that allows you to execute external operating system commands (like
files) directly from within the Creo Parametric environment. By using the
prefix in a mapkey definition, you can automate tasks that go beyond CAD modeling, such as file management, launching external apps, or running custom scripts. PTC Community Core Example: Executing a Batch File To run an OS script, the mapkey must use the command followed by the path to your executable or script. PTC Community Mapkey Syntax (in config.pro mapkey os_run @SYSTEM C:\scripts\my_script.bat; Detailed Feature Review Description Automation Scope
Allows Creo to interact with the Windows environment, enabling tasks like copying config files or opening specific project folders in File Explorer. Ease of Execution
Once defined, the script can be triggered via a custom keyboard shortcut, eliminating the need to minimize Creo or use the background terminal. Scripting Flexibility Supports various script types, including VBScript (.vbs) Batch files (.bat) , and other executables. Integration
Can be placed at the end of a regular CAD mapkey to "clean up" or "finalize" a task, such as archiving a newly exported PDF. Implementation Tips & Best Practices Path Formatting : Use double backslashes ( ) in the path if editing the config.pro file manually to ensure the system reads them correctly. Legibility : If your OS command has multiple lines, use a backslash (
) at the end of each line except the last to keep the code organized. External Apps : You can use the command to launch websites or programs. For example: @SYSTEM start http://ptc.com; Advanced Use Cases AutoIt scripts
to read the Creo window title or trail files, allowing the mapkey to perform context-aware actions like opening the exact folder where a part is stored.
: If the "OS Script" tab is greyed out in the Mapkey dialog, you may need to manually add the line to your config.pro using a text editor. PTC Community batch script example
for a task like automatically moving exported DXF files to a project folder? Mapkey Writing/Editing Tips - PTC Community
Creating a mapkey that executes an Operating System (OS) script is a powerful way to automate tasks outside of Creo Parametric, such as moving files, running batch scripts, or launching external applications like a calculator. Defining an OS Script Mapkey
You can create these mapkeys through the Creo interface or by manually editing your config.pro (or mapkeys.pro in newer versions like Creo 11). Method 1: Using the Creo Interface Navigate to File > Options > Mapkeys Settings. Click New to open the Record Mapkey dialog box. Assign a Keyboard Shortcut (e.g., calc). Switch to the OS Script tab.
Type the command you wish to execute. For example, to open the Windows Calculator, simply type calculator.exe. Click OK and then Save to your configuration file. Method 2: Manual Syntax for config.pro
If you prefer to edit your configuration file directly, use the @SYSTEM command followed by the OS path or command.
Example 1: Running a Batch FileTo run a script located in a specific directory, use the following syntax. Note that Creo requires double backslashes (\\) to escape standard file paths. mapkey run_bat @SYSTEMcall C:\\Scripts\\cleanup.bat; Use code with caution. Copied to clipboard
Example 2: Using System VariablesYou can make your scripts more dynamic by using Creo-specific system variables like $USERPROFILE or $USERNAME.
mapkey my_script @SYSTEMcall $USERPROFILE\\Documents\\automation_tool.bat; Use code with caution. Copied to clipboard Key Technical Details
The OS Script Tab: This feature allows you to run OS commands without minimizing the Creo window, making it seamless for tasks like copying configuration files into a working directory.
Command Syntax: Use call before a batch file name to ensure the script executes correctly and returns control to Creo once finished.
File Locations: In Creo Parametric 11, mapkeys have moved from config.pro to a dedicated mapkeys.pro file located in the user's %appdata% folder.
Automation Workflow: Advanced users often use OS scripts to generate Trail Files, which Creo can then play back to perform complex modeling actions. About Mapkeys - Creo Parametric - PTC Support Portal
To execute Operating System (OS) scripts within a Creo mapkey, use the @SYSTEM prefix or the OS Script tab in the Mapkeys dialog. Example: Running a Batch File
If you want to run a Windows batch script (e.g., C:\scripts\cleanup.bat) via a mapkey shortcut like cc, the configuration line in your config.pro would look like this:
mapkey cc @MAPKEY_LABEL Run Cleanup Script; @SYSTEM C:\scripts\cleanup.bat; Use code with caution. Copied to clipboard Scripting via the User Interface
Open the Mapkeys dialog via File > Options > Mapkey Settings (or search "mapkey" in the search bar).
Click New and define your keyboard shortcut (e.g., myscript). Go to the OS Script tab. Enter your command, such as: Open a folder: explorer . (opens current working directory) Run a Python script: python C:\path\to\script.py Open Windows Calculator: calc.exe
Click Save to ensure the mapkey persists in your Mapkeys.pro or config.pro file. Key Formatting Rules Creo Parametric - Mapkeys [Configuration]