I am learning python and want to edit the configuration files of VSCode to toggle the selected theme, but I can't find the file controlling the configuration settings. The below file-path is where I've narrowed it down to so far:
C:\Users\<Name>\AppData\Local\Programs\Microsoft VS Code
I've also come across this thread from 2016
https://github.com/Microsoft/vscode/issues/10046
Which pointed me here, though I'm still sifting through the thread
https://github.com/Microsoft/vscode/issues/3884#issuecomment-230912738
This thread is from 2016, and the old and new versions they mention are not up to date.
Old Settings: %APPDATA%\Code[ - Variant]\User\settings.json
New Settings: %APPDATA%\Microsoft\[Visual Studio ]Code[ - Variant]\settings.json
The current user setting locations are covered in the VS Code docs:
Windows: %APPDATA%\Code\User\settings.json
macOS: $HOME/Library/Application Support/Code/User/settings.json
Linux: $HOME/.config/Code/User/settings.json
(For insiders, use Code - Insiders instead)
I've a simple project in visual studio code with some defined tasks in tasks.json. Let's say the task are labeled with foo and bar.
Inside of visual studio code I can run CTRL+B and select the wanted task.
But - How can I run the task foo from a command line outside of Visual Studio Code?
There is a python tool that runs the vscode tasks. The last commit was in 2018, but it still might work as it seems that the tasks were last changed in vscode 1.13, released in 2017.
edit:
It works but setup.py:8 needs to be edited to build the wheel on windows, as it tries to run a shell script. My edit was to change the line to log = subprocess.check_output('sh bin/changelog') as I have sh installed.
I want to use Visual Studio Code as my main IDE, but I want to compile my code with IAR's compiler.
How could I configure VSCode ?
I found this extension but the documentation is too poor.
Yes, the extension politoleo.iar is indeed NOT good.
-> I found a better one (will try it in future by myself):
VSCode plugin: pluyckx.iar-vsc
IAR For Visual Studio Code - Visual Studio Marketplace
Good document
Welcome to IAR-VSC’s documentation! — IAR-VSC 1.2 documentation
doc's Github source: pluyckx/iar-vsc
IAR related official Technical Note
Using Visual Studio Code with IAR Embedded Workbench
Enjoy it !
There are now two official IAR plugins for VSCode which make things much easier:
For building and development: https://marketplace.visualstudio.com/items?itemName=iarsystems.iar-build
For debugging with C-Spy: https://marketplace.visualstudio.com/items?itemName=iarsystems.iar-debug
https://www.iar.com/knowledge/support/technical-notes/general/using-visual-studio-code-with-iar-embedded-workbench/
What I did is setting some environment variables in settings.json;
then in tasks.json I created shell tasks that call the IarBuild.exe & IarIdePm.exe with appropriate values (see the documentation on the command line options)...
So now, I can use VSCode for navigation & editing, but the compilation is done by the EWARM.
The only thing that I haven't figure out yet is how to make C-Spy work from within VSCode...
Currently when I want to debug, I just launch the EWARM and debug from there...
here is a screenshot:Screenshot of settings.json and tasks.json
For this, you can port you project to the custom build system (non iarbuild), e.g. a best choose is the Qbs. The Qbs support a lot of architectures and the toolchains (include IAR, KEIL and so on). In this case you can then use any IDE which support the Qbs, e.g. such as VSCode or QtCreator, and to open your project in any of these IDEs.
Both IDEs support only the GDB debugging, because the C-Spy debuger is a proptietary technology, which has not the public datasheets.
How is it possible to export all Visual Studio Code settings and plugins and import them to another machine?
With the current version of Visual Studio Code as of this writing (1.22.1), you can find your settings in:
~/.config/Code/User on Linux
%APPDATA%\Code\User (C:\Users\username\AppData\Roaming\Code\User) on Windows
~/Library/Application Support/Code/User/ on Mac OS X
The files are settings.json and keybindings.json. Simply copy them to the target machine.
Your extensions are in:
~/.vscode/extensions on Linux and Mac OS X
%USERPROFILE%\.vscode\extensions (C:\Users\username\.vscode\extensions) on Windows (i.e., essentially the same place as on Linux and Mac OS X)
Alternately, just go to the Extensions, show installed extensions, and install those on your target installation. For me, copying the extensions worked just fine, but it may be extension-specific, particularly if moving between platforms, depending on what the extension does.
There is an extension for Visual Studio Code, called Settings Sync.
It synchronises your settings by gist (Gist by GitHub). It works the same as the Atom.io extension called settings-sync.
UPDATE:
This feature is now build in VS Code, it is worth to switch to official feature.
(https://stackoverflow.com/a/64035356/2029818)
You can now sync all your settings across devices with VSCode's built-in Settings Sync. It's found under Code > Preferences > Turn on Settings Sync...
Similar to the answer given by Big Rich you can do the following:
$ code --list-extensions | xargs -L 1 echo code --install-extension
This will list out your extensions with the command to install them so you can just copy and paste the entire output into your other machine:
Example:
code --install-extension EditorConfig.EditorConfig
code --install-extension aaron-bond.better-comments
code --install-extension christian-kohler.npm-intellisense
code --install-extension christian-kohler.path-intellisense
code --install-extension CoenraadS.bracket-pair-colorizer
It is taken from the answer given here.
Note: Make sure you have added VS Code to your path beforehand. On mac you can do the following:
Launch Visual Studio Code
Open the Command Palette (⇧ + ⌘ + P) and type 'shell command' to find the
Shell Command: Install 'code' command in PATH command.
For posterity, this post mentions,
in the latest release of Visual Studio Code (May 2016) it is now possible to list
the installed extension in the command line
code --list-extensions
On Mac, execute something like:
"/Applications/Visual Studio Code.app//Contents/Resources/app/bin/code" --list-extensions
To install, use:
--install-extension <ext> //see 'code --help'
You can now synchronise all your settings across devices with Visual Studio Code's built-in Settings Sync. It's found under menu File → Preferences → Turn on Settings Sync...
Read more about it in the official documentation here.
Your user settings are in ~/Library/Application\ Support/Code/User.
If you're not concerned about synchronising and it's a one-time thing, you can just copy the files keybindings.json and settings.json to the corresponding folder on your new machine.
Your extensions are in the ~/.vscode folder. Most extensions aren't using any native bindings and they should be working properly when copied over.
You can manually reinstall those who do not.
I'm preferred my own way to synchronize all Visual Studio Code extensions between laptops, using .dotfiles and small script to perform updates automatically. This way helps me every time when I want to install all extensions I have without any single mouse activity in Visual Studio Code after installing (via Homebrew).
So I just write each new added extension to .txt file stored at my .dotfiles folder. After that I pull master branch on another laptop to get up-to-date file with all extensions.
Using the script, which Big Rich had written before, with one more change, I can totally synchronise all extensions almost automatically.
Script
cat dart-extensions.txt | xargs -L 1 code --install-extension
And also there is one more way to automate that process. Here you can add a script which looks up a Visual Studio Code extension in realtime and each time when you take a diff between the code --list-extensions command and your .txt file in .dotfiles, you can easily update your file and push it to your remote repository.
I've made a Python script for exporting Visual Studio Code settings into a single ZIP file:
https://gist.github.com/wonderbeyond/661c686b64cb0cabb77a43b49b16b26e
You can upload the ZIP file to external storage.
$ vsc-settings.py export
Exporting vsc settings:
created a temporary dump dir /tmp/tmpf88wo142
generating extensions list
copying /home/wonder/.config/Code/User/settings.json
copying /home/wonder/.config/Code/User/keybindings.json
copying /home/wonder/.config/Code/User/projects.json
copying /home/wonder/.config/Code/User/snippets
adding: snippets/ (stored 0%)
adding: snippets/go.json (deflated 56%)
adding: projects.json (deflated 67%)
adding: extensions.txt (deflated 40%)
adding: keybindings.json (deflated 81%)
adding: settings.json (deflated 59%)
VSC settings exported into /home/wonder/vsc-settings-2019-02-25-171337.zip
$ unzip -l /home/wonder/vsc-settings-2019-02-25-171337.zip
Archive: /home/wonder/vsc-settings-2019-02-25-171337.zip
Length Date Time Name
--------- ---------- ----- ----
0 2019-02-25 17:13 snippets/
942 2019-02-25 17:13 snippets/go.json
519 2019-02-25 17:13 projects.json
471 2019-02-25 17:13 extensions.txt
2429 2019-02-25 17:13 keybindings.json
2224 2019-02-25 17:13 settings.json
--------- -------
6585 6 files
PS: You may implement the vsc-settings.py import subcommand for me.
This is my syncing configuration repo for VSCodium (for Linux only). If you use VSCode, just replace the codium with code and the syncing will be fine.
https://github.com/vanvuvuong/codium_configuration
Enable Portable Mode
Portable Mode instructs Visual Studio Code to store all its configuration and plugins in a specific directory (called data/ in Windows and Linux and code-portable-data in macOS).
At any time you could copy the data directory and copy it on another installation.
VS Code provides 2 options to take care your settings. One is import/Export and other is Sync settings with github profile.
Follow below steps to Export VS code settings
Search for 'Profiles: Export' in the Command Palette (Ctrl+Shift+P).
Select 'what to export' and confirm by clicking on 'OK'
Name you export -
Select Local file which will download file
To import, choose 'Profiles: Import' from Command Palette
Often there are questions about the Java settings in Visual Studio Code. This is a big question and can involve advanced user knowledge to accomplish. But there is simple way to get the existing Java settings from Visual Studio Code and copy these setting for use on another PC. This post is using recent versions of Visual Studio Code and JDK in mid-December 2020.
There are several screen shots (below) that accompany this post which should provide enough information for the visual learners.
First things first, open Visual Studio Code and either open an existing Java folder-file or create a new Java file in Visual Studio Code. Then look at the lower right corner of Visual Studio Code (on the blue command bar). The Visual Studio Code should be displaying an icon showing the version of the Java Standard Edition (Java SE) being used. The version being on this PC today is JavaSE-15. (link 1)
Click on that icon (JAVASE-15) which then opens a new window named "java.configuration.runtimes". There should be two tabs below this name: User and Workspace. Below these tabs is a link named, "Edit in settings.json". Click on that link. (Link 2)
Two json files should then open: Default settings and settings.json. This post only focuses on the "settings.json" file.
The settings.json file shows various settings used for coding different programming languages (Python, R, and Java). Near the bottom of the settings.json file shows the settings this User uses in Visual Studio Code for programming Java.
These Java settings are the settings that can be "backed up" - meaning these settings get copied and pasted to another PC for creating a Java programming environment similar to the Java programming environment on this PC. (Link 3)
Link 1
Link 2
Link 3
For those looking for an export option for Visual Studio (not Code), use Tools menu, select "Export selected environment settings"
I have a C# project that relies on a few services. I've written a PowerShell script that checks if the services are running and starts them if they're not. I'm currently running the script manually, but it would be better if I could configure Visual Studio to run the script every time I start debugging the project.
I experimented with using the post-build events, but that only works (obviously) when the project has been changed and needs to be rebuilt. If there is a solution that allows me to run the PowerShell script regardless of whether the project is being rebuilt, that would be excellent.
I had a similar requirement. This is what i did:
Installed the powershell tools from the Visual Studio 2013 gallery
Added a project to the solution of the (newly installed) Powershell Project type
Added a Powershell script to start the services (in my case a Redis Server)
Added this project to the solution "set startup projects" (right-click on the Solution Explorer top level solution node) using the multiple startup projects setting