Installing rstan with miniconda environment

I followed the installation instructions that you’ve provided but am still having problems getting it to work.

I use R in a miniconda environment on windows. I installed R tools using the default where Rtools40 is located at C:/rtools40. I then stored the path in an .Rprofile because I was wondering if that was what the problem was:

usethis::edit_r_profile()

and pasted the following into my .Rprofile

PATH="${RTOOLS40_HOME}\\usr\\bin;${PATH}"

I then opened my conda environment and started R:

$ conda activate pirate
$ R
>

I checked to make sure that it could find my ‘make’

> Sys.which('make')
                              make 
"C:\\rtools40\\usr\\bin\\make.exe"

And that seemed to be the same thing as I should have given the instructions.

But then when I tried to use the example model:

> example(stan_model, package = "rstan", run.dontrun = TRUE)
Loading required package: StanHeaders
Loading required package: ggplot2
rstan (Version 2.21.5, GitRev: 2e1f913d3ca3)
For execution on a local, multicore CPU with excess RAM we recommend calling
options(mc.cores = parallel::detectCores()).
To avoid recompilation of unchanged Stan programs, we recommend calling
rstan_options(auto_write = TRUE)
Do not specify '-march=native' in 'LOCAL_CPPFLAGS' or a Makevars file

stn_md> stancode <- 'data {real y_mean;} parameters {real y;} model {y ~ normal(y_mean,1);}'

stn_md> mod <- stan_model(model_code = stancode, verbose = TRUE)

TRANSLATING MODEL '73fc79f8b1915e8208c736914c86d1a1' FROM Stan CODE TO C++ CODE NOW.
successful in parsing the Stan model '73fc79f8b1915e8208c736914c86d1a1'.
COMPILING THE C++ CODE FOR MODEL '73fc79f8b1915e8208c736914c86d1a1' NOW.
OS: x86_64, mingw32; rstan: 2.21.5; Rcpp: 1.0.9; inline: 0.3.19
 >> setting environment variables: 
LOCAL_LIBS =  "C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/rstan/lib/x64/libStanServices.a" -L"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/libs/x64" -lStanHeaders -L"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppParallel/lib/x64" -ltbb
PKG_CPPFLAGS =   -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/Rcpp/include/"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppEigen/include/"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppEigen/include/unsupported"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/BH/include" -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/include/src/"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/include/"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppParallel/include/"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/rstan/include" -DEIGEN_NO_DEBUG  -DBOOST_DISABLE_ASSERTS  -DBOOST_PENDING_INTEGER_LOG2_HPP  -DSTAN_THREADS  -DBOOST_NO_AUTO_PTR  -include "C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/include/stan/math/prim/mat/fun/Eigen.hpp"  -std=c++1y
 >> Program source :

   1 :
   2 : // includes from the plugin
   3 : // [[Rcpp::plugins(cpp14)]]
   4 :
   5 :
   6 : // user includes
   7 : #include <Rcpp.h>
   8 : #include <rstan/io/rlist_ref_var_context.hpp>
   9 : #include <rstan/io/r_ostream.hpp>
  10 : #include <rstan/stan_args.hpp>
  11 : #include <boost/integer/integer_log2.hpp>
  12 : // Code generated by Stan version 2.21.0
  13 :
  14 : #include <stan/model/model_header.hpp>
  15 :
  16 : namespace model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1_namespace {
  17 :
  18 : using std::istream;
  19 : using std::string;
  20 : using std::stringstream;
  21 : using std::vector;
  22 : using stan::io::dump;
  23 : using stan::math::lgamma;
  24 : using stan::model::prob_grad;
  25 : using namespace stan::math;
  26 :
  27 : static int current_statement_begin__;
  28 :
  29 : stan::io::program_reader prog_reader__() {
  30 :     stan::io::program_reader reader;
  31 :     reader.add_event(0, 0, "start", "model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1");
  32 :     reader.add_event(3, 1, "end", "model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1");
  33 :     return reader;
  34 : }
  35 :
  36 : class model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1
  37 :   : public stan::model::model_base_crtp<model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1> {
  38 : private:
  39 :         double y_mean;
  40 : public:
  41 :     model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1(rstan::io::rlist_ref_var_context& context__,
  42 :         std::ostream* pstream__ = 0)
  43 :         : model_base_crtp(0) {
  44 :         ctor_body(context__, 0, pstream__);
  45 :     }
  46 :
  47 :     model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1(stan::io::var_context& context__,
  48 :         unsigned int random_seed__,
  49 :         std::ostream* pstream__ = 0)
  50 :         : model_base_crtp(0) {
  51 :         ctor_body(context__, random_seed__, pstream__);
  52 :     }
  53 :
  54 :     void ctor_body(stan::io::var_context& context__,
  55 :                    unsigned int random_seed__,
  56 :                    std::ostream* pstream__) {
  57 :         typedef double local_scalar_t__;
  58 :
  59 :         boost::ecuyer1988 base_rng__ =
  60 :           stan::services::util::create_rng(random_seed__, 0);
  61 :         (void) base_rng__;  // suppress unused var warning
  62 :
  63 :         current_statement_begin__ = -1;
  64 :
  65 :         static const char* function__ = "model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1_namespace::model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1";
  66 :         (void) function__;  // dummy to suppress unused var warning
  67 :         size_t pos__;
  68 :         (void) pos__;  // dummy to suppress unused var warning
  69 :         std::vector<int> vals_i__;
  70 :         std::vector<double> vals_r__;
  71 :         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
  72 :         (void) DUMMY_VAR__;  // suppress unused var warning
  73 :
  74 :         try {
  75 :             // initialize data block variables from context__
  76 :             current_statement_begin__ = 1;
  77 :             context__.validate_dims("data initialization", "y_mean", "double", context__.to_vec());
  78 :             y_mean = double(0);
  79 :             vals_r__ = context__.vals_r("y_mean");
  80 :             pos__ = 0;
  81 :             y_mean = vals_r__[pos__++];
  82 :
  83 :
  84 :             // initialize transformed data variables
  85 :             // execute transformed data statements
  86 :
  87 :             // validate transformed data
  88 :
  89 :             // validate, set parameter ranges
  90 :             num_params_r__ = 0U;
  91 :             param_ranges_i__.clear();
  92 :             current_statement_begin__ = 1;
  93 :             num_params_r__ += 1;
  94 :         } catch (const std::exception& e) {
  95 :             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
  96 :             // Next line prevents compiler griping about no return
  97 :             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
  98 :         }
  99 :     }
 100 :
 101 :     ~model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1() { }
 102 :
 103 :
 104 :     void transform_inits(const stan::io::var_context& context__,
 105 :                          std::vector<int>& params_i__,
 106 :                          std::vector<double>& params_r__,
 107 :                          std::ostream* pstream__) const {
 108 :         typedef double local_scalar_t__;
 109 :         stan::io::writer<double> writer__(params_r__, params_i__);
 110 :         size_t pos__;
 111 :         (void) pos__; // dummy call to supress warning
 112 :         std::vector<double> vals_r__;
 113 :         std::vector<int> vals_i__;
 114 :
 115 :         current_statement_begin__ = 1;
 116 :         if (!(context__.contains_r("y")))
 117 :             stan::lang::rethrow_located(std::runtime_error(std::string("Variable y missing")), current_statement_begin__, prog_reader__());
 118 :         vals_r__ = context__.vals_r("y");
 119 :         pos__ = 0U;
 120 :         context__.validate_dims("parameter initialization", "y", "double", context__.to_vec());
 121 :         double y(0);
 122 :         y = vals_r__[pos__++];
 123 :         try {
 124 :             writer__.scalar_unconstrain(y);
 125 :         } catch (const std::exception& e) {
 126 :             stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable y: ") + e.what()), current_statement_begin__, prog_reader__());
 127 :         }
 128 :
 129 :         params_r__ = writer__.data_r();
 130 :         params_i__ = writer__.data_i();
 131 :     }
 132 :
 133 :     void transform_inits(const stan::io::var_context& context,
 134 :                          Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
 135 :                          std::ostream* pstream__) const {
 136 :       std::vector<double> params_r_vec;
 137 :       std::vector<int> params_i_vec;
 138 :       transform_inits(context, params_i_vec, params_r_vec, pstream__);
 139 :       params_r.resize(params_r_vec.size());
 140 :       for (int i = 0; i < params_r.size(); ++i)
 141 :         params_r(i) = params_r_vec[i];
 142 :     }
 143 :
 144 :
 145 :     template <bool propto__, bool jacobian__, typename T__>
 146 :     T__ log_prob(std::vector<T__>& params_r__,
 147 :                  std::vector<int>& params_i__,
 148 :                  std::ostream* pstream__ = 0) const {
 149 :
 150 :         typedef T__ local_scalar_t__;
 151 :
 152 :         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
 153 :         (void) DUMMY_VAR__;  // dummy to suppress unused var warning
 154 :
 155 :         T__ lp__(0.0);
 156 :         stan::math::accumulator<T__> lp_accum__;
 157 :         try {
 158 :             stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
 159 :
 160 :             // model parameters
 161 :             current_statement_begin__ = 1;
 162 :             local_scalar_t__ y;
 163 :             (void) y;  // dummy to suppress unused var warning
 164 :             if (jacobian__)
 165 :                 y = in__.scalar_constrain(lp__);
 166 :             else
 167 :                 y = in__.scalar_constrain();
 168 :
 169 :             // model body
 170 :
 171 :             current_statement_begin__ = 1;
 172 :             lp_accum__.add(normal_log<propto__>(y, y_mean, 1));
 173 :
 174 :         } catch (const std::exception& e) {
 175 :             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
 176 :             // Next line prevents compiler griping about no return
 177 :             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
 178 :         }
 179 :
 180 :         lp_accum__.add(lp__);
 181 :         return lp_accum__.sum();
 182 :
 183 :     } // log_prob()
 184 :
 185 :     template <bool propto, bool jacobian, typename T_>
 186 :     T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
 187 :                std::ostream* pstream = 0) const {
 188 :       std::vector<T_> vec_params_r;
 189 :       vec_params_r.reserve(params_r.size());
 190 :       for (int i = 0; i < params_r.size(); ++i)
 191 :         vec_params_r.push_back(params_r(i));
 192 :       std::vector<int> vec_params_i;
 193 :       return log_prob<propto,jacobian,T_>(vec_params_r, vec_params_i, pstream);
 194 :     }
 195 :
 196 :
 197 :     void get_param_names(std::vector<std::string>& names__) const {
 198 :         names__.resize(0);
 199 :         names__.push_back("y");
 200 :     }
 201 :
 202 :
 203 :     void get_dims(std::vector<std::vector<size_t> >& dimss__) const {
 204 :         dimss__.resize(0);
 205 :         std::vector<size_t> dims__;
 206 :         dims__.resize(0);
 207 :         dimss__.push_back(dims__);
 208 :     }
 209 :
 210 :     template <typename RNG>
 211 :     void write_array(RNG& base_rng__,
 212 :                      std::vector<double>& params_r__,
 213 :                      std::vector<int>& params_i__,
 214 :                      std::vector<double>& vars__,
 215 :                      bool include_tparams__ = true,
 216 :                      bool include_gqs__ = true,
 217 :                      std::ostream* pstream__ = 0) const {
 218 :         typedef double local_scalar_t__;
 219 :
 220 :         vars__.resize(0);
 221 :         stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
 222 :         static const char* function__ = "model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1_namespace::write_array";
 223 :         (void) function__;  // dummy to suppress unused var warning
 224 :
 225 :         // read-transform, write parameters
 226 :         double y = in__.scalar_constrain();
 227 :         vars__.push_back(y);
 228 :
 229 :         double lp__ = 0.0;
 230 :         (void) lp__;  // dummy to suppress unused var warning
 231 :         stan::math::accumulator<double> lp_accum__;
 232 :
 233 :         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
 234 :         (void) DUMMY_VAR__;  // suppress unused var warning
 235 :
 236 :         if (!include_tparams__ && !include_gqs__) return;
 237 :
 238 :         try {
 239 :             if (!include_gqs__ && !include_tparams__) return;
 240 :             if (!include_gqs__) return;
 241 :         } catch (const std::exception& e) {
 242 :             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
 243 :             // Next line prevents compiler griping about no return
 244 :             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
 245 :         }
 246 :     }
 247 : 
 248 :     template <typename RNG>
 249 :     void write_array(RNG& base_rng,
 250 :                      Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
 251 :                      Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
 252 :                      bool include_tparams = true,
 253 :                      bool include_gqs = true,
 254 :                      std::ostream* pstream = 0) const {
 255 :       std::vector<double> params_r_vec(params_r.size());
 256 :       for (int i = 0; i < params_r.size(); ++i)
 257 :         params_r_vec[i] = params_r(i);
 258 :       std::vector<double> vars_vec;
 259 :       std::vector<int> params_i_vec;
 260 :       write_array(base_rng, params_r_vec, params_i_vec, vars_vec, include_tparams, include_gqs, pstream);
 261 :       vars.resize(vars_vec.size());
 262 :       for (int i = 0; i < vars.size(); ++i)
 263 :         vars(i) = vars_vec[i];
 264 :     }
 265 :
 266 :     std::string model_name() const {
 267 :         return "model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1";
 268 :     }
 269 :
 270 :
 271 :     void constrained_param_names(std::vector<std::string>& param_names__,
 272 :                                  bool include_tparams__ = true,
 273 :                                  bool include_gqs__ = true) const {
 274 :         std::stringstream param_name_stream__;
 275 :         param_name_stream__.str(std::string());
 276 :         param_name_stream__ << "y";
 277 :         param_names__.push_back(param_name_stream__.str());
 278 :
 279 :         if (!include_gqs__ && !include_tparams__) return;
 280 :
 281 :         if (include_tparams__) {
 282 :         }
 283 :
 284 :         if (!include_gqs__) return;
 285 :     }
 286 :
 287 :
 288 :     void unconstrained_param_names(std::vector<std::string>& param_names__,
 289 :                                    bool include_tparams__ = true,
 290 :                                    bool include_gqs__ = true) const {
 291 :         std::stringstream param_name_stream__;
 292 :         param_name_stream__.str(std::string());
 293 :         param_name_stream__ << "y";
 294 :         param_names__.push_back(param_name_stream__.str());
 295 :
 296 :         if (!include_gqs__ && !include_tparams__) return;
 297 :
 298 :         if (include_tparams__) {
 299 :         }
 300 : 
 301 :         if (!include_gqs__) return;
 302 :     }
 303 :
 304 : }; // model
 305 :
 306 : }  // namespace
 307 :
 308 : typedef model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1_namespace::model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1 stan_model;
 309 :
 310 : #ifndef USING_R
 311 :
 312 : stan::model::model_base& new_model(
 313 :         stan::io::var_context& data_context,
 314 :         unsigned int seed,
 315 :         std::ostream* msg_stream) {
 316 :   stan_model* m = new stan_model(data_context, seed, msg_stream);
 317 :   return *m;
 318 : }
 319 :
 320 : #endif
 321 :
 322 :
 323 :
 324 : #include <rstan_next/stan_fit.hpp>
 325 :
 326 : struct stan_model_holder {
 327 :     stan_model_holder(rstan::io::rlist_ref_var_context rcontext,
 328 :                       unsigned int random_seed)
 329 :     : rcontext_(rcontext), random_seed_(random_seed)
 330 :      {
 331 :      }
 332 :
 333 :    //stan::math::ChainableStack ad_stack;
 334 :    rstan::io::rlist_ref_var_context rcontext_;
 335 :    unsigned int random_seed_;
 336 : };
 337 :
 338 : Rcpp::XPtr<stan::model::model_base> model_ptr(stan_model_holder* smh) {
 339 :   Rcpp::XPtr<stan::model::model_base> model_instance(new stan_model(smh->rcontext_, smh->random_seed_), true);
 340 :   return model_instance;
 341 : }
 342 :
 343 : Rcpp::XPtr<rstan::stan_fit_base> fit_ptr(stan_model_holder* smh) {
 344 :   return Rcpp::XPtr<rstan::stan_fit_base>(new rstan::stan_fit(model_ptr(smh), smh->random_seed_), true);
 345 : }
 346 :
 347 : std::string model_name(stan_model_holder* smh) {
 348 :   return model_ptr(smh).get()->model_name();
 349 : }
 350 :
 351 : RCPP_MODULE(stan_fit4model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1_mod){
 352 :   Rcpp::class_<stan_model_holder>("stan_fit4model2e7c402b56b4_73fc79f8b1915e8208c736914c86d1a1")
 353 :   .constructor<rstan::io::rlist_ref_var_context, unsigned int>()
 354 :   .method("model_ptr", &model_ptr)
 355 :   .method("fit_ptr", &fit_ptr)
 356 :   .method("model_name", &model_name)
 357 :   ;
 358 : }
 359 :
 360 :
 361 : // declarations
 362 : extern "C" {
 363 : SEXP file2e7c17d3142( ) ;
 364 : }
 365 :
 366 : // definition
 367 : SEXP file2e7c17d3142() {
 368 :  return Rcpp::wrap("73fc79f8b1915e8208c736914c86d1a1");
 369 : }
make cmd is
  make -f "C:/Users/damon/ANACON~1/envs/pirate/lib/R/etc/x64/Makeconf" -f "C:/Users/damon/ANACON~1/envs/pirate/lib/R/share/make/winshlib.mk" CXX='$(CXX14) $(CXX14STD)' CXXFLAGS='$(CXX14FLAGS)' CXXPICFLAGS='$(CXX14PICFLAGS)' SHLIB_LDFLAGS='$(SHLIB_CXX14LDFLAGS)' SHLIB_LD='$(SHLIB_CXX14LD)' SHLIB="file2e7c17d3142.dll" WIN=64 TCLBIN=64 OBJECTS="file2e7c17d3142.o"

make would use
g++  -std=gnu++14 -I"C:/Users/damon/ANACON~1/envs/pirate/lib/R/include" -DNDEBUG   -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/Rcpp/include/"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppEigen/include/"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppEigen/include/unsupported"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/BH/include" -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/include/src/"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/include/"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppParallel/include/"  -I"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/rstan/include" -DEIGEN_NO_DEBUG  -DBOOST_DISABLE_ASSERTS  -DBOOST_PENDING_INTEGER_LOG2_HPP  -DSTAN_THREADS  -DBOOST_NO_AUTO_PTR  -include "C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/include/stan/math/prim/mat/fun/Eigen.hpp"  -std=c++1y         -O2 -Wall  -march=x86-64 -mtune=generic  -c file2e7c17d3142.cpp -o file2e7c17d3142.o
if test "zfile2e7c17d3142.o" != "z"; then \
  if test -e "file2e7c17d3142-win.def"; then \
    echo g++  -shared -s -o file2e7c17d3142.dll file2e7c17d3142-win.def file2e7c17d3142.o   "C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/rstan/lib/x64/libStanServices.a" -L"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/libs/x64" -lStanHeaders -L"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppParallel/lib/x64" -ltbb  -L"C:/Users/damon/ANACON~1/envs/pirate/lib/R/bin/x64" -lR ; \
    g++  -shared -s -o file2e7c17d3142.dll file2e7c17d3142-win.def file2e7c17d3142.o   "C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/rstan/lib/x64/libStanServices.a" -L"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/libs/x64" -lStanHeaders -L"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppParallel/lib/x64" -ltbb  -L"C:/Users/damon/ANACON~1/envs/pirate/lib/R/bin/x64" -lR ; \
  else \
    echo EXPORTS > tmp.def; \
    nm file2e7c17d3142.o | sed -n 's/^.* [BCDRT] / /p' | sed -e '/[.]refptr[.]/d' -e '/[.]weak[.]/d' | sed 's/[^ ][^ ]*/"&"/g'  >> tmp.def; \
    echo g++  -shared -s -o file2e7c17d3142.dll tmp.def file2e7c17d3142.o   "C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/rstan/lib/x64/libStanServices.a" -L"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/libs/x64" -lStanHeaders -L"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppParallel/lib/x64" -ltbb  -L"C:/Users/damon/ANACON~1/envs/pirate/lib/R/bin/x64" -lR ; \
    g++  -shared -s -o file2e7c17d3142.dll tmp.def file2e7c17d3142.o   "C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/rstan/lib/x64/libStanServices.a" -L"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/StanHeaders/libs/x64" -lStanHeaders -L"C:/Users/damon/anaconda3/envs/pirate/Lib/R/library/RcppParallel/lib/x64" -ltbb  -L"C:/Users/damon/ANACON~1/envs/pirate/lib/R/bin/x64" -lR ; \
    rm -f tmp.def; \
  fi \
fi

stn_md> fit <- sampling(mod, data = list(y_mean = 0))
Segmentation fault

I get a segmentation fault and it stops my session. My guess is that there is probably something wrong with how I reference Rtools to compile, but I just don’t know much about how this stuff works to figure it out.

Any help would be much appreciated!!

Thank you for the detailed error output. This will bump your message to the top. Sorry I don’t use miniconda but I know a number of folks around here do.