https://community.wolfram.com RSS Feed for Wolfram Community showing ideas tagged with Product Set Up sorted by active. https://community.wolfram.com/groups/-/m/t/3201543 ![Setup local AI with Ollama and Wolfram: A step-by-step guide for configuring on Windows systems][1] # Ollama setup (post-it note instructions) Set a Windows User Environment Variable OLLAMA_ORIGINS with a value of * (Start -> Settings -> System -> About -> Advanced System Settings (on the right) -> Advanced (tab) -> Environment Variables -> Add a new one on top) Here's your HTTP request. The "ExportString" is the magic: ollamaHttpRequest[model_, contextSize_, context_, seed_, streaming_, prompt_] := HTTPRequest["http://127.0.0.1:11434/api/generate", <|"Method" -> "POST", "Headers" -> <|"Content-Type" -> "application/json"|>, "Body" -> ExportString[ <|"model" -> model, "prompt" -> prompt, "context" -> context, "stream" -> streaming, "options" -> <|"seed" -> seed, "num_ctx" -> contextSize|>|>, "JSON"]|>]; Do a URLRead on that to send it to Ollama and you get an object from Ollama you can parse (should give you a '200' status server code). Here's how you parse a non-streaming response: ollamaReadSingle[ollamaHttpResponse_] := Association[ImportString[ollamaHttpResponse["Body"], "JSON"]]; And here's how you parse a streaming one: ollamaReadStreaming[ollamaHttpResponse_] := Association[#] &@ImportString[#, "JSON"] & /@ StringSplit[ollamaHttpResponse["Body"], "\n"]; Confirming this doesn't to async responses yet (so you will wait even if you put in "streaming" unless you figure that part out). Didn't see this anywhere else. As much fun as it is being the only person in the world with a barely-working prototype... # Streaming Chat Setup I am under the impression there is more interest in using Ollama with Mathematica. I've got quite a few features working, and would like to share. The idea with this is if you're a grad student or armchair researcher, you can get up and running with Ollama and start experimenting today. If you're not using Ollama, it is available at [ollama.com][2]. It is a free and runs AIs locally on your computer (with extensive use of your graphics card to generate responses). Attached is a notebook with an extensible framework that I hope will permit further experimentation with GPTs. Some features are included already. It's tested, but not extensively. **Instructions are for Windows**, however there are parallel functions and features for Mac and Linux (and these instructions are also much more extensively covered online). All this model does is stream chat requests - it does not pull additional models, list what models you have, or run any other commands besides sending a streaming chat request (though it should be relatively easy to extend these features). **Crash Course** If you're already using Ollama, the crash course is to run the commands to load the model names, variables, and functions in the "Run Once" section, then scroll down to the bottom and enjoy. You may need to add an "OLLAMA_ORIGINS" environment variable (detailed below). If this is your first time using Ollama, you will want to use Powershell to download at least one model file (this contains all the weights [the "brains"] of the AI). You should also attempt to start a Powershell chat session with the model to make sure it is returning responses, and there is no issue with Ollama failing to run. If you are having issues running Ollama commands from Powershell, see if you can navigate to the installation folder, typically %AppData%\Local\Programs\Ollama, and attempt to run the commands there. If commands work from the Ollama installation folder, then the Ollama path is likely missing from your "Path" environment variable. **Ollama Environment Variables** Unless you do application configuration for a living, this is probably your first time hearing about environment variables. There are a few that you'll want to set / unset / know what they do. To get into these (on Windows 10), go to Start -> Settings -> System -> About, and click "Advanced system settings" on the right. On the "System Properties" window, go to the "Advanced" tab and click "Environment Variables". You should get the following window: ![enter image description here][3] (I removed my system irrelevant variables for obvious security reasons, but you should have a lot.) You may click "New" to add further variables. You will need to add "OLLAMA_ORIGINS" and set the value to "*://localhost" as in the example so that Ollama is allowed to receive connections from your own computer. If you click on "Path" and click "Edit", you may have the path to the Ollama install directory in here. This allows Powershell, the Run dialog, and other things to run Ollama without needing to reference the entire folder path in the command line. "OLLAMA_MODELS" will let you specify a different directory to download models into. Lastly, please confirm that Mathematica is allowed to access the Internet (on version 12, this option is under Edit -> Preferences -> Internet & Mail). **Building Ollama HTTP Requests** Most of the HTTP request is built using Mathematica association datatypes - this is mostly just a list where values are assigned to a named "key" as well as maintaining an array position, and can be called by the name of the key. Same as I've mentioned in an earlier post, the secret to getting the HTTP requests to work is to export *just the body* of the HTTP request association to JSON: ollamaHttpRequest[bodyAssociation_] := HTTPRequest["http://127.0.0.1:11434/api/generate", <|"Method" -> "POST", "Headers" -> <|"Content-Type" -> "application/json"|>, "Body" -> ExportString[bodyAssociation, "JSON"]|>]; This portion works for streaming responses as well as single-body responses. The notebook attached builds the request in phases using a temporary association variable, beginning with a basic request saved to a temporary variable, and **appending** further body tags to that temporary variable before returning it as the result of the function: ollamaHttpRequestBody[ollamaOptions_] := ( ollamaTempHttpRequestBody = <|"model" -> ollamaInputModelString, "prompt" -> ollamaInputFuncUserPromptString, "stream" -> True, "keep_alive" -> ollamaInputKeepAliveString, "options" -> ollamaOptions|>; (* Context - Included if not empty *) If[ollamaUseContext && (ollamaVarCurrentConversationList != {}), ollamaTempHttpRequestBody = Append[ollamaTempHttpRequestBody, "context" -> ollamaInputFuncSelectedContext]]; (* Template *) If[ollamaUseTemplate, ollamaTempHttpRequestBody = Append[ollamaTempHttpRequestBody, "template" -> ollamaInputTemplateString]]; (* System Prompt *) If[ollamaUseSystem, ollamaTempHttpRequestBody = Append[ollamaTempHttpRequestBody, "system" -> ollamaInputSystemPromptString]]; (* Image - Included if this model is a vision model *) If[ollamaUseImage && ollamaFuncIsBoolVision[ollamaInputModelString], ollamaTempHttpRequestBody = Append[ollamaTempHttpRequestBody, "images" -> ollamaInputFuncImageList]]; (* Include further body tags in here *) (* This returns just the temporary HTTP request body association \ variable as the result of the function *) ollamaTempHttpRequestBody ); The "Options" portion of the request is built much the same way, as are the image and prompt parsing functions. This is done to allow easy extensibility - simply include an additional Boolean flag and pass the prompt or image to a manipulation function. **Saving Information** The notebook will save the contents of each query, and can be further extended to save further information by passing variables to Current Query Association variable (such as image sizes and CRC32 file hashes), as demonstrated below in the image builder. This function will take an input of a list of paths of images, and first import the files so the files can have information saved (such as the size and hash), and then are converted into raw images so they can be manipulated, resized and the like, and then re-exported into JPG format for use as input into Ollama: ollamaInputFuncImageList := ( (* Appends the image paths to the query *) ollamaVarCurrentQueryAssociation = Append[ollamaVarCurrentQueryAssociation, "imagePaths" -> ollamaVarImagePathsString]; (* Splits the single string list of files up at the semicolons \ into a list of file paths *) ollamaTempFilePathsList = ollamaFuncGetImagePathsStringList[ollamaVarImagePathsString]; (* Entire image files are imported as binary objects *) ollamaTempImageFileList = ByteArray /@ (Import[#, "Byte"] & /@ ollamaTempFilePathsList); (* Appends the size of the images to the current query association \ *) ollamaVarCurrentQueryAssociation = Append[ollamaVarCurrentQueryAssociation, "imageFileSizes" -> (Length[#] & /@ ollamaTempImageFileList)]; (* Also appends a list of file hashes *) ollamaVarCurrentQueryAssociation = Append[ollamaVarCurrentQueryAssociation, "imageHashesCRC32" -> (ollamaFuncImageFileHashString[#, "CRC32"] & /@ ollamaTempImageFileList)]; (* The binary object image files are imported again in the image \ format, so it is now editable by image functions *) ollamaTempImagesList = ImportByteArray[#] & /@ ollamaTempImageFileList; (* This runs all the edits we want to apply to our images *) ollamaTempImagesList = ollamaFuncAlterImage[#] & /@ ollamaTempImagesList; (* Returns the list of images for inclusion in the HTTP request *) ToCharacterCode[ExportString[#, "JPG"]] & /@ ollamaTempImagesList); **Receiving Streaming Responses** On URL submission, the Ollama server will begin returning responses. HTTP requests can be manually submitted via the use of the URL Submit function (however this notebook will call the URL Submit function with a number of other helper functions): ollamaVarResponseTask = URLSubmit[ ollamaHttpRequest[ollamaTempHttpRequestBody], HandlerFunctions -> <| "HeadersReceived" -> (ollamaFuncHandlerHeaders[#Headers] &), "BodyChunkReceived" -> (ollamaFuncHandlerBodyChunks[#BodyChunk] \ &), "ConnectionFailed" -> (Print[ "Connection Failed: Ollama is probably not running."] &), "TaskFinished" -> (ollamaFuncHandlerTaskFinished &), "TaskStatusChanged" -> (ollamaFuncHandlerTaskInterrupt[#Task, \ #TaskStatus] &) |>, HandlerFunctionsKeys -> {"BodyChunk", "Headers", "Task", "TaskStatus"}]; When setting up the URL Submit, you will *want* to save the URLSubmit command to a variable to keep track of the "task". This task variable may be used later to interrupt the query by the use of the "TaskRemove" function. For a streaming response, URL Submit will need to be provided with "handler functions", and "handler function keys". Handler functions are called when certain HTTP events take place, such as a body chunk is received (usually containing a single token), when the response is finished, interrupted, when headers are received, etc.. Handler function keys are values passed with the event. A simple example is the headers handler, which just saves the returned headers into the current query association under the "headers" key: ollamaFuncHandlerHeaders[ headers_] := (ollamaVarCurrentQueryAssociation = Append[ollamaVarCurrentQueryAssociation, "headers" -> headers];); It is okay to receive responses just as a string without attempting to import them from JSON into an association, especially when debugging. **Issues & Future Work** There may be some issues with the body chunks received. Some may be sent back empty, and some may be sent back incomplete (with the completed portions sent in subsequent body chunk responses). The notebook attached will parse some of these issues, but it seems like some new models can introduce new issues. There are further notes within the notebook detailing how to tell if it's running, how to handle crashes and the like. Mostly you'll want to check your graphics usage, specifically the "Cuda" usage, but there are other signs things are working or not. Please feel free to extend & upload the attached notebook at will. I won't be adding features, but if there are errors or bugs I may fix them & reupload (it's a lot of code, I'm sure I've missed some things, but I feel like this is good enough to publish at present). # Setup and usage details &[Wolfram Notebook][4] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Image20241018183644.jpg&userId=20103 [2]: http://ollama.com [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=EnvironmentVariables.png&userId=2392475 [4]: https://www.wolframcloud.com/obj/68e4cc4b-ea49-495f-8540-215467295fc6 Cameron Kosina 2024-06-29T06:07:36Z https://community.wolfram.com/groups/-/m/t/3254456 **Wolfram Prerelease** is open to new beta testers! Your feedback will be very useful and will improve future releases of Wolfram products. If you're interested in participating in this program and receive the latest builds, please apply by sending an email to prerelease@wolfram.com with a self-intro and license number if you're an existing customer. Jay Yao 2024-08-23T19:30:12Z https://community.wolfram.com/groups/-/m/t/1266184 Thought I'd post something I was struggling with in order to get Mathematica (and any sub-menus it might launch) to display correctly on high resolution monitors in Linux. The default ScreenResolution is 72dpi in a newly installed Mathematica. My monitor (and almost all modern monitors) use a higher resolution. In my case 96dpi. This means that everything rendered is tiny (it renders to 72/96 of what it was intended to run at). Controlling some fonts fails to control sizes in menus, icons, and tool bars in general. Bits and pieces of Mathematica can be enlarged through font or ScreenResolution changes, but it is difficult at best to get even part of what is too small back to a normal size. So here is how to fix this with a single step... Setting environment variables like this will fix the issue...note that 96/72, the dpi of actual monitor versus what seems to sometimes be hard coded into Mathematica, is about 1.33. This will correct the issue if starting on command line: QT_AUTO_SCREEN_SCALE_FACTOR=1 QT_SCALE_FACTOR=1.33 Mathematica & Starting Mathematica like this will allow the palettes, icons, buttons, and window frames to enlarge uniformly. Dan Stimits 2018-01-16T02:04:25Z https://community.wolfram.com/groups/-/m/t/3103515 This is a guide for installing Mathematica ARM Version (Raspberry Pi) on Android devices with a full GUI. The guide assumes that one has Termux-x11 and proot-distro working in order to have a GUI. You are required to have a Mathematica key for Linux to activate. [Termux][1] and [Termux-x11][2] are a terminal and x11-forwarding implementation for Android devices. There is no root requirement, thus the security of your device will not be compromised. Please refer to these guides in order to install and get them working. [Proot-distro][3] is a quick way to get a linux distro to work on Android devices. It is not a virtual machine because all installed distros are the ARM64 version to work with most phones/tablets' processors. Rather, proot-distro is a container environment manager, handling/hijacking system IO and storage to emulate chroot and mount for non-rooted devices, thus if your device is rooted, you do not need to install proot-distro. Because it is not a virtual machine, you have almost full processing speed except for the IO hijacking, giving a minor hit to the performance. However, as long as the calculation in Mathematica does not involve a lot of IOs, performance is very decent. Please follow the guide and install the debian (for rooted device, install debian using whatever you want). Here, we need debian because the ARM version of Mathematica is built for Raspbian originally, which is debian-based, thus using debian via proot-distro helps to handle some system dependents that native Termux does not have. It is my goal in the future to have Mathematica working natively on Termux to get native performance. Inputs/helps are needed and welcome! **How to Install Wolfram Kernel (back end):** - Start proot-distro debian by proot-distro login debian - Allow a multi-architecture (64+32-bit) and install 32-bit libraries because Mathematica uses some of these (the latter is optional, but it might help in case you see some error related to 32-bit instruction) dpkg --add-architecture armhf apt install libatomic1:armhf libgl1:armhf - Download the [Raspberry Pi installation script][4] from Wolfram and put it in the root folder of debian. You should have access to your usual Android "Download" folder through cd //sdcard/Download/ - Execute the official installation script (Current version is 13.3.1, but this might change when they release new version) bash ./install-wolfram-engine-13.3.1.sh - At this point, everything should be set. You can activate Mathematica by starting its Kernel and follow the instruction (I activate sucessfully using a Linux Mathematica Key provided by my institution) wolfram - After activation, you should have been forwarded to the Wolfram CLI Kernel, where we have full access to the Kernel (back end). To quit, execute Quit[] **How to run Mathematica GUI (front end):** - Start the Termux-x11 app on your Android device and a termux terminal. Then, start an x11 instance by executing in Termux terminal termux-x11 :1 & If Termux and Termux-x11 have been installed correctly, you should see the x11 app window black and the mouse cursor is an x. - Start debian with x-11 forwarding proot-distro login debian --shared-tmp - Set display to the previously started (1 in this case) export DISPLAY=:1 - Optional step: Install xfce4 desktop environment to have full multi-window desktop experience (otherwise you cannot control fullscreen window in x11 window) apt install xfce4 To start the desktop environment (you should see the x11 app with full desktop interface now) xfce4-session & - Start Mathematica from command line mathematica & and you should see the Raspberry Pi Mathematica window pop-up! Tested device: Samsung Tab S9 with Snapdragon 8 gen 2 runnning Android 14 + One UI 6. [1]: https://github.com/termux/termux-app [2]: https://github.com/termux/termux-x11 [3]: https://github.com/termux/proot-distro [4]: https://www.wolfram.com/raspberry-pi/ Quan Le Thien 2024-01-15T18:07:20Z https://community.wolfram.com/groups/-/m/t/1290781 I recently upgraded to Mathematica 11 for some side projects. I love the program, but I was annoyed to see that there is no keyboard shortcut for the Evaluate Notebook command. F8 appears to be unused in the normal configuration on Linux. So I’m posting a solution for adding F8 as a keyboard shortcut for Evaluate Notebook: If you are on Linux, all you have to do is edit /usr/local/Wolfram/Mathematica/11.2/SystemFiles/FrontEnd/TextResources/X/MenuSetup.tr 1. Make a backup of MenuSetup.tr 2. Open MenuSetup.tr 2. Search for “Evaluate Notebook” 3. You’ll find the correct line (there is only one). Add ‘, MenuKey[“F8”, Modifiers->{}]’ after “EvaluateNotebook” 4. The revised line should read ‘MenuItem[“Evaluate N&otebook”, “EvaluateNotebook”, MenuKey[“F8”, Modifiers->{}]],’ 5. Re-launch Mathematica, and you should see F8 next to the Evaluate Notebook command. Try it out. 6. Success! Is there some reason why there is no keyboard shortcut for Evaluate Notebook? I am at a loss because it is simple to add one. Andrew Watters 2018-02-23T17:03:02Z https://community.wolfram.com/groups/-/m/t/2167291 Since, from what I understand the bundle license for personal use of Mathematica is tied to the Raspberry hardware and not to the Raspian OS, and since I prefer the 64-bit version of Kali Linux to Raspian, here the steps I took to get Mathematica working on my RasPi under Kali Linux: - In case you haven’t done so, make an attempt of making your installation a 32/64-bit multi-architecture system: dpkg --add-architecture armhf apt -y update - download the Raspberry Pi Mathematica Installer from Wolfram Research wget https://wolfr.am/wolfram-engine-raspi-install - run whatever script the above link downloads, currently that’s: (and this may take a while, as it downloads the bulk of the install) bash ./install-wolfram-engine-13.1.0.sh - as Mathematica installs 32-bit binaries, it may have overlooked some following dependencies, the 64-bit versions of these libraries were already on my system and may have been taken for granted (although it might have been installed as a dependency for something else...) As new releases come, this may resolve itself, you'll just have to watch the error messages and act accordingly... apt install libatomic1:armhf libgl1:armhf - Mathematica requires rather questionable access to `/dev/vchiq` and `/dev/fb0` the latter of which is already group `video` with group read-write access. For `/dev/vchiq` we need to do this manually. Not sure I’m happy about the security implications of this… (In case future versions of Kali have different default permissions, commented out the otherwise required steps for `/dev/fb0` ) #chgrp video /dev/fb0 chgrp video /dev/vchiq #chmod g+rw /dev/fb0 chmod g+rw /dev/vchiq - for each non-root user who wants to successfully use Mathematica, the following is required: sudo usermod -a -G video $(whoami) That should do it, things work, etc. There are however a few issues, to summarize: 1) I’m not sure how comfortable anyone should be with non-privileged users getting access to `/dev/fb0` and `/dev/vchiq` just to run Mathematica. If access to such resources is required, then that should be something handled in a privileged task and not require giving users wholesale access to devices. 2) As pointed out elsewhere in this forum, Mathematica failing with a seemingly totally unrelated licensing failure when access to these devices isn’t granted, is less than ideal. Unless one happens to stumble across this thread here [On Raspberry Pi 2, how do I get beyond the 'Product Activation' dialog?][1] good luck figuring out what’s the actual problem... 3) The install script, while otherwise rather good at installing dependencies, missed the dependency on `libatomic1` and `libgl1` which consequently had to be installed manually, which is only in so far a problem as it’s another failure point, and, in case of a future de-installation of Mathematica, will linger as ghost, unless equally manually removed. 4) Of course, we’d all be even happier, if we could finally see an `arm64` rather than the `armhf` version of Mathematica, so the higher-end Raspberry Pi can effectively use their CPU and RAM most efficiently. But this is a good bridge solution for the time being, at least I won’t have to run a 32-bit kernel or OS anymore. Anyway, enjoy! Hope this is helpful for someone... [1]: https://community.wolfram.com/groups/-/m/t/444854 Ronald Antony 2021-01-19T18:19:52Z https://community.wolfram.com/groups/-/m/t/2570909 **Technical Support advisory**: RESOLVED. The updated installer is now available in the **Wolfram User Portal** and **Wolfram Account**. ---------- **Original advisory**: The original Wolfram Language 13.1 documentation installer for Linux has a serious bug. If the installation is stopped before completing, files in the user directory may be deleted. We are actively working on a fix, but note that this issue is not triggered if the documentation installs successfully. If you have already installed the Wolfram Language 13.1 documentation, there is no reason to uninstall. Please discard any copies of the original installer. A new installer will be available in the Wolfram User Portal and Wolfram Account as soon as testing concludes. EDITORIAL BOARD 2022-07-15T01:33:56Z https://community.wolfram.com/groups/-/m/t/2565612 This is to let you know: I just recognized that the Mathematica Upgrade 13.1 on Windows does not uninstall the 13.0.1 Documentation. The old documentation can be easily uninstalled via the Windows System. Otherwise, 7.72 GB will remain unused on your system. Jürgen Kanz 2022-07-07T09:29:14Z https://community.wolfram.com/groups/-/m/t/2561290 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/e16ff341-02a9-4ecb-a7b3-58912885f4af Daniel Carvalho 2022-07-01T03:54:11Z https://community.wolfram.com/groups/-/m/t/2396714 Just wanted to report that I installed MacOS Monterey yesterday and have had no problems so far running any of my Mathematica applications. Your mileage may vary of course, so be careful. I am running a 2018 Mac Mini 3 GHz 6-Core Intel Core i5 with 32 GB 2667 MHz DDR4. No Apple silicon yet, but Christmas is just around the corner. John Shonder 2021-10-30T12:45:34Z https://community.wolfram.com/groups/-/m/t/1951871 The iPad Pro is already way more powerful than a lot of notebooks so it makes a lot of sense now to have a full version of Mathematica running locally instead of just the Wolfram Cloud app. This would also be a good excuse to provide full Metal support so GPUs in the Apple ecosystem would be supported for computation as well and not just graphics. maxscience n 2020-04-23T12:31:14Z https://community.wolfram.com/groups/-/m/t/157340 [i]Mathematica [/i]and The Wolfram Language are now available from ours and the Raspberry Pi foundation's software repositories for the default Raspbian Linux distribution for the Pi. If you're running a Raspbian image provided by the Raspberry Pi foundation, you can now install the software with the following steps: [list=1] [*]Ensure that you have at least [b]600[/b] megabytes of free storage on your Raspberry Pi's SD card. The package itself will take up 429 megabytes of disk space when installed. [*][code]$ sudo apt-get update && sudo apt-get install wolfram-engine[/code] [*]Agree to the licensing terms displayed (Use tab to move between fields in the license window. You will only need to do this once). [*]Wait for the installation to complete.  [/list]You should now find Mathematica and the Wolfram Language installed on the LXDE desktop under the [b]Education[/b] menu and the Wolfram Language under the [b]Programming [/b] menu. In order to start the application from the Linux command line, type:[code]$ wolfram[/code]To start Mathematica, type:[code]$ mathematica[/code] If you have any questions about installing the application on your Raspberry Pi, feel free to ask!  Alex Newman 2013-11-21T17:12:50Z https://community.wolfram.com/groups/-/m/t/1855244 Here are two simple but extremely convenient keyboard shortcuts that I've used for years. - This post is a favor to all my friends who type slowly (like me) - These shortcuts simply create a pair of brackets containing a template placeholder as the current new selection - Essentially, it's just a stripped-down version of the bulky (Command + Shift + K + Up/Down Arrow + Enter) completion **Favorite Shortcut #1:** Autocomplete single brackets by pressing `CommandKey + [` ![enter image description here][1] **Favorite Shortcut #2:** Autocomplete part brackets by pressing `CommandKey + ]` ![enter image description here][2] ## How to set them up ## On MacOS, first make a backup of the following file, in case you break it: FileNameJoin[{$InstallationDirectory, "SystemFiles/FrontEnd/TextResources/Macintosh/KeyEventTranslations.tr"}]; On my machine this path resolves to: *"/Applications/Mathematica.app/Contents/SystemFiles/FrontEnd/TextResources/Macintosh/KeyEventTranslations.tr"* Then, preferably in a non-Mathematica editor (e.g. Sublime), open the above file and copy-and-paste these following code into the list inside `EventTranslations`. For the first shortcut: Item[KeyEvent["[",Modifiers->{Command}],FrontEndExecute[{FrontEnd`NotebookWrite[FrontEnd`InputNotebook[],"[\[SelectionPlaceholder]]"],FrontEndToken["MovePreviousPlaceHolder"]}]] And for the second (of course making sure they are separated by a comma): Item[KeyEvent["]",Modifiers->{Command}],FrontEndExecute[{FrontEnd`NotebookWrite[FrontEnd`InputNotebook[],"\[LeftDoubleBracket]\[SelectionPlaceholder]\[RightDoubleBracket]"],FrontEndToken["MovePreviousPlaceHolder"],FrontEndToken["MovePreviousPlaceHolder"]}]] Finally, restart Mathematica, and presto, they should both be working. And to remove the shortcuts, simply remove those items or replace the .tr file with the backup. [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=own.gif&userId=900170 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=part.gif&userId=900170 Michael Sollami 2020-01-08T20:42:08Z https://community.wolfram.com/groups/-/m/t/1028536 Hi all, Mathematica 11.0.1 is now available for the Raspberry Pi on Raspbian. If you already have Mathematica installed on your Raspberry Pi, you can update with the following: sudo apt-get update && sudo apt-get upgrade wolfram-engine If you don't already have Mathematica installed you can run the following commands to install it: sudo apt-get update && sudo apt-get install wolfram-engine New features for the Raspberry Pi include : - Neural Network features including constructing custom nets : http://reference.wolfram.com/language/guide/NeuralNetworks.html - Audio processing features including out of core streaming of large sounds as well as advanced audio processing : http://reference.wolfram.com/language/guide/AudioProcessing.html - Travel based path plan functions including path finding from one city to another : http://reference.wolfram.com/language/guide/LocationsPathsAndRouting.html - Channel based communication for sending and receiving messages : http://reference.wolfram.com/language/guide/Channel-BasedCommunication.html - Powerful and easy scripting through WolframScript : http://reference.wolfram.com/language/ref/program/wolframscript.html - And many more : http://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn11.html Additionally, with the new release of WolframScript on the Raspberry Pi, you can install WolframScript standalone and run it without a local kernel against the cloud using the `-cloud` option. This means you can use the Wolfram Language through WolframScript on the Raspberry Pi without having wolfram-engine installed by running it against the cloud. See the documentation page for WolframScript for more details. Ian Johnson 2017-03-09T21:02:49Z https://community.wolfram.com/groups/-/m/t/1717637 The attached notebook is the product of a lot of errors on my part. And I hear that even very sophisticated Wolfram Language users are having difficulty with the installation. Here's my effort to clarify some of the hidden steps you may need to take. If you like it, let people know. If it has errors or incompleteness, let people know. I think the ability to access the Wolfram Language through Jupyter is a great thing for the Wolfram Ecosystem. The more people who can take advantage of the opportunity without a soul gutting out-of-box experience, the better. ##Step 1 : Figure out where the heck Jupyter is installed on your system## You might as well do this first. If you don' t where Jupyter is, all of this is unlikely to work. On my Mac I use Jupyter through Anaconda. So I kind of thought it was there. I ultimately found a command called jupyter_mac.command in this directory where /Users/sethchandler is my "home" directory. jupyterLocation = "/Users/sethchandler/anaconda3/bin"; Now we have to fiddle with the "Path Environment" for this session. Here's my current environment. initialEnvironment = GetEnvironment["PATH"] > "PATH" -> "/usr/bin:/bin:/usr/sbin:/sbin" It' s a bunch of directory paths separated by colons. Now let' s change it. SetEnvironment["PATH" -> StringJoin["PATH" /. initialEnvironment, ":", jupyterLocation]] Check if it worked GetEnvironment["PATH"] > "PATH" -> > "/usr/bin:/bin:/usr/sbin:/sbin:/Users/sethchandler/anaconda3/bin" ##Step 2 : Get the Wolfram Language code you will need; it' s in a file## 1. Browse to here: https://github.com/WolframResearch/WolframLanguageForJupyter/blob/master/configure-jupyter.wls 2. Press the Raw button. 3. Go the browser menu and click Save Page As or whatever saves files. Put the file somewhere you will remember it. Now a bunch of Wolfram Language code is on your local machine. ##Step 3 : Get the Paclet## 1. Browse to here : https : // github.com/WolframResearch/WolframLanguageForJupyter/releases 2. Click on Assets 3. Click on WolframLanguageForJupyter-0.9 .1.paclet or whatever the current number is. This should start a standard download process. Stick the file somewhere on your machine where you will remember it. ##Step 4 : Install the Paclet## I stuck my paclet in the Downloads directory of my user directory. PacletInstall["/Users/sethchandler/Downloads/WolframLanguageForJupyter-0.9.1.paclet"] ##Step 5: Load up the Package that was in the Paclet## Needs["WolframLanguageForJupyter`"] ##Step 6 : Do it!## Invoke whatever form of secular of divine imprecations work best for you and run this : ConfigureJupyter["Add"] If nothing happens after about 5 seconds, that' s perfect. Look below to "prove" that it worked. ![enter image description here][1] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=73441.png&userId=20103 Seth Chandler 2019-07-02T14:23:25Z https://community.wolfram.com/groups/-/m/t/1315124 **ToString** is a routine in *Mathematica*, that has default FormatType -> OutputForm and that has no attribute HoldFirst. For applications for the Interpreter for TEX it makes more sense to have attribute HoldFirst. When this is used, then other forms may get HoldForm in the output string. It is easy to remove the latter again for InputForm. Since this works fine, it makes sense to make the latter the new default. Since ToString is such a core routine, this new functionality can better be provided by a new routine **TwoString** that builds around ToString. Alternative names are **TooString** or **MakeString**. It is suggested to the makers of *Mathematica* that ToString is adapted with options HoldFirst -> True and HoldForm -> False for this particular use just like TwoString (with default InputForm and the removal of HoldForm from the output string). It would be useful to have some TeXString[*expr*] object with HoldFirst such that *expr* would be readable by a TEX interpreter. PM. I regard all of this as a minor issue, but it just crossed my path. https://www.wolframcloud.com/objects/thomas-cool/Utilities/2018-04-05-TwoString.nb Thomas Colignatus 2018-04-05T17:44:28Z https://community.wolfram.com/groups/-/m/t/1280603 Let's get right to it, Anna Musser and I spent some time this weekend experimenting with the LightBoard setup at MIT to see if we could make some engaging video tutorials for complete Mathematica novices. I know my acting needs some work, but we would love to hear any thoughts about the use of this type of system to produce video tutorials for coding in Wolfram Language using Mathematica. Also Let us know if you have any tools you use to produce videos and teach in more engaging ways! There are two videos linked below, the first is a video about opening Mathematica for the first time and below that is a video about completing assignments using the [CodeSeal computational curriculum framework][1] [Intro to Mathematica][2] [![screen shot of a video lecture showing Kyle Keane][3]][7] [Overview of CodeSeal][4] [![screen shot of video lecture showing Kyle Keane and CodeSeal][5]][6] [1]: http://www.codeseal.org [2]: https://www.youtube.com/watch?v=LzKcFYlw_5A [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=IntrotoMathematica.00_07_26_12.Still001.png&userId=26311 [4]: https://www.youtube.com/watch?v=aNMRA_7ojws&t=6s [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=IntrotoMathematica.00_23_25_27.Still002.png&userId=26311 [6]: https://www.youtube.com/watch?v=aNMRA_7ojws&t=6s [7]: https://www.youtube.com/watch?v=LzKcFYlw_5A Kyle Keane 2018-02-07T05:43:28Z https://community.wolfram.com/groups/-/m/t/930559 Once again Apple change the requirements checked by Gatekeeper so if you try to start SystemModeler you will be presented with this dialog: ![enter image description here][1] To get around that you can right click (or Ctrl click) and select open ![enter image description here][2] You will then get a new dialog with the option to start SystemModeler anyway. ![enter image description here][3] This will always allow SystemModeler to start so you only need to follow this procedure the first time you start SystemModeler on macOS Sierra. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=CannotOpenDialog.png&userId=23166 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=OpenContext.png&userId=23166 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=OpenDialog.png&userId=23166 Otto Tronarp 2016-09-27T09:11:16Z https://community.wolfram.com/groups/-/m/t/871482 I am the author of Package-X (http://packagex.hepforge.org) the documentation for which I used Wolfram Workbench extensively. An update to Wolfram Workbench would be welcome by me. Hiren Patel 2016-06-12T14:43:21Z https://community.wolfram.com/groups/-/m/t/828333 If you upgrade your Macintosh to MacOSX 10.11.4 and then install Mathematica 10.4.0, this installation will be blocked from running by the operating system. We are working to resolving this issue. The suggested workaround is, - locate the Mathematica.app bundle in Finder (Applications folder), - control-click (or right-click) to get the context menu, and ![Control-/right-click popup menu][1] - select Open from the context menu. - There will still be a warning message. Click Open to approve running the new Mathematica. ![identity-of-developer message][2] [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-03-23at2.25.48PM.png&userId=17902 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=16668449.535.png&userId=17902 Bruce Miller 2016-03-23T18:46:20Z