" I am sorry I would not understand the meaning of the question correctly. 
BigDecimal for money calculation. running clj major libraries on cljs (ex. Instaparse).
"
"(optional) eval"
"(remote) debugger, ie an ability to connect to browser environment and debug the code from same IDE as I edit the code. Debug = stop, pause, inspect local variables etc.

This is a definitely top wishlist which would simplify the development. 

I agree with Stu Halloway that you should not need the debugger. This holds for functional Clojure code, where code can be split into small and well tested parts. Unfortunately it is no more true when you need to deal with multiple javascript libraries. Without debugger you are left with prn/console.log statements."
"-"
"-property is a failure of the compiler that made it into the language. Let's nuke it."
"A cljs-repl middleware (like Cider) for a better Cljs development experience that mirrors that for the JVM. For example, looking up docs or source for a cljs function should be as easy."
"Ability to target OSX JavaScript bridge, for writing full OSX applications in ClojureScript."
"Actually number types including bignums"
"Anything that might aid debugging."
"Auto generated externs that work"
"Awesome interoperability with Clojure (build tools)."
"Being propper Lisp independent from Clojure (being able to dynamically generate code in clojurescript itself)"
"Better (native) error messages. "
"Better compile-time errors"
"Better compiler error reporting."
"Better console printing so I can inspect objects when they are printed "
"Better control over the generated javascript"
"Better debugging"
"Better debugging"
"Better debugging facilities."
"Better dependency management"
"Better documentation of optimizaitons and what you do for each. For example, the fact that optimizations :none requires inlining of js, but none of the other options do, is kind of awkward and painful."
"Better error messages"
"Better error messages"
"Better error reporting"
"Better externs."
"Better integration with node.js, require, browserify and friends. Targeting ES6."
"Better integration with the browser / easier "debuggability""
"Better interop with JS libraries"
"Better jQuery interopability (although jayq somewhat covers this)"
"Better macro support"
"Better repl ! Or at least a better documentation around it... "
"Better runtime error detection"
"Better support for requiring macros. I want to require macros and fns from a namespace with a single require form. None of the existing solutions (:refer-macros, :include-macros, :require-macros) does that."
"Better support of non-browser targets (in my case, the QML runtime where the only working optimization setting is :simple (?!))."
"Better tutorials for backend experts who don't know enough frontend stuff just yet.  ClojureScript for Clojure devs that don't pretend to understand javascript."
"BigDecimal would be nice..."
"Bootstrapped compiler that does not require JVM."
"Bootstrapped node/clojurescript compiler?"
"Bridge the gap between functions in Clojure.core and ClojureScript more (where it makes sense, I know, I know)"
"CLJS in CLJS."
"Can't think of any!"
"Can't think of any."
"CinC"
"CinC, in-browser compilation."
"Cleaner macro `refer` - it's confusing sometimes when you need to explicitly refer a macro."
"Clojure-in-Clojure"
"ClojureScript in ClojureScript"
"ClojureScript in ClojureScript compiler"
"ClojureScript in the browser (i.e. from the browser console)"
"ClojureScript is so overwhelmingly superior to JavaScript in the browser that I can't even think of one."
"Compiler warnings should be errors, as in clojure. No more "undefined is not a function"."
"Complete feature parity with Clojure."
"Conversion from-to javascript collections."
"Cross-compilation, e.g. via feature expressions."
"Debugging"
"Dunno, still learning the existing ones.
I have an idea though... async modular projects would be neat (think requires, webpack).
A compiler/loader system similar to web pack with an ability to preprocess a project and emit every kind of resources project needs in a modular asynchronously loadable form (css, images, web fonts, svg, js)."
"Dynamic Interop"
"Easier REPL support for editors"
"Easier built in browser repl"
"Easier in browser REPL and in browser debugging of CLJS source."
"Easier syntax for native JS interaction."
"Easier tests (which I guess is a tooling problem)."
"Easier to understand docs on setting up a cljs repl"
"Either interop with js data structures, or compiler detection of when I've missed a clj->js or whatever it is"
"Equality defined for closures"
"Eval"
"Everything in Clojure that is not in Clojurescript."
"Fast tuples."
"Faster quick-start for node.js projects.  Perhaps just an improved lein template for the same?"
"Feature Expressions"
"Feature Expressions"
"Feature expressions"
"Feature expressions"
"Feature expressions for ease of code reuse between clojure and clojurescript projects."
"Feature expressions."
"Feature tags"
"Features (compilation)"
"First class continuations"
"First class support for Float32Array and friends"
"Generators support"
"Haven't thought about it very hard. Anything that improves interop (both ease and performance) is a win."
"Having ClojureScript be self hosted"
"Hot module reload"
"I am a beginner so I don't know yet"
"I just don't know enough. I think smoother tools are probably much more important than language features. "
"I really wish ClojureScript faked threading like GHCJS. "
"I would like to have things that allow the ClojureScript REPL to be more like the Clojure REPL: use 'namespace :reload, in-ns, etc."
"I would love to see it at a matching version number with Clojure, with all of the features (to the extent they are applicable in the JS environment) finished, tested, etc. to the same extent as the parent language."
"I'd like to see clj's extend implemented in cljs!"
"Illuminated macros. "
"Include JavaScript dependencies in library so they can be compiled in by users of that library without requiring a separate download and/or inclusion via script tag. "
"Inline JavaScript, which on the other hand might turn out to be a really bad idea in the long run though."
"Inline-macros, feature-expressions for easy cljs/clj code-sharing."
"Introspection of clojurescript "namespaces""
"JSX, to replace the awkward (dom/div #js {:attr "value"}) in Om."
"Just stop; it's fine."
"Language support for channels."
"Less dependence on host features.  Trying to get the dates and times in Clojure and Clojurescript to work is nuts.  It would be nice if simple stuff like that just worked."
"Macro - better way to integrate into language itself."
"Macros in ClojureScript, or at least a hack that makes this less annoying."
"Macros in runtime."
"Macros in the same file, evaluated against the correct (target) environment."
"Macros that don't rely on Clojure. "
"Macros written in ClojureScript."
"Make it easy to break up large applications into separately downloadable modules (e.g., groups of namespaces)."
"More compatibility with JVM Clojure."
"More compatibility with JavaScript's data types (lists, objects) - sure it's not the same as Java, but if integrating with some JS libraries (e.g. AngularJS)  it becomes painful."
"More integration into clojure.
It would be nice to be able to compile a namespace or function from within clojure with a function call."
"More robust node.js support"
"More straightforward Browser REPL integration -- it is VERY confusing to try and configure at the moment."
"More third party libraries integrated."
"More unit tests for the core. Something in our application breaks appeoximately every third release."
"Name *one* language feature you would like to see added to ClojureScript."
"Namespaces as JS modules (ES6 Modules)."
"Native support for emulated numeric tower like Clojure's (Long, BigInt, BigDecimal, Ratio, etc)."
"None"
"Not a language feature, but seeing more contrib libraries, like "core.matrix" in ClojureScript would be great."
"Not a language feature, but would like better compile time error reporting. Also would love core.typed driven optimisation. Can't think of an actual language feature I want."
"Not enough experience to think of one yet.. recently was missing a pretty printing facility similar to Clojure's pprint"
"Not exactly a language feature, but sometimes the error messages are less than helpful. It would be great to have clearer error messages."
"Nothing"
"Nothing I can think of; there are some weird outstanding issues with Google Closure Compiler in advanced compilation mode (e.g. https://code.google.com/p/closure-library/issues/detail?id=642)"
"Nothing has stuck out as sorely needed"
"Official feature expressions would be great (ala Cljx)."
"Overcome the single-threaded model of JavaScript by using webworkers under the hood. A future would automatically be executed in a webworker."
"Package management / dependency management, very unclear how to manage JS libraries in comparison to Java jars"
"Parallel processing (web workers?)"
"Parity with namespace semantics Clojure/Clojurescript."
"Private functions"
"Regular macros"
"Remove dependency on JVM"
"Remove need for JVM Clojure for writing macros."
"Self hosting"
"Self hosting."
"Self-hosted compiler (targeting node.js and browsers ideally, not Rhino) to make things like hacking the compiler and writing in-browser REPLs easier."
"Self-hosting"
"Self-hosting"
"Self-hosting"
"Self-hosting"
"Self-hosting and macros."
"Self-hosting to enable simplification of the tool chain."
"Self-hosting! Real CLJS macros would be awesome!"
"Sharing the same codebase betwenen clj and cljs"
"Since we already have pattern matching, static types e CSP, make cljx powers first class will be VERY welcome. "
"Some way to get rid of that separate macros file thing."
"Sourcemaps, Sourcemaps !"
"Standardized Component."
"Static typing in the compiler"
"Static typing."
"Static typing."
"TCO"
"Tail Call Optimization"
"Tail call optimization"
"Triple quoted strings."
"Types"
"Unified macros (don't run the macros in the JVM)"
"Warnings about undefined variables in other namespaces, e.g. calling my-ns/non-existent from a function in other-ns."
"Warnings for unbound vars.  Nearly always accidental on my part, but takes a while to track down."
"a compiler that runs on V8"
"a self-hosted version would be awesome"
"a standard unit test lib"
"auto-timing of generated javascript functions"
"automatic js extern handling (so we don't have to write extern files)"
"better error messaging"
"better exceptions.  everyone writes their own dev exception wrappers with wrappers (for example i shadow let and any form under it).  would love to not have to do that."
"better guidance on getting started from the mothership"
"better integration with browser ( elm-lang demos seem much better than what we have clojure-script)"
"better macro experience"
"better/easier setup"
"bring (format) back!"
"browser connected nrepl with easy setup phase"
"bump version number from 0.0.x to 1.x.y to convince my boss it's mature ;-)) "
"cljs-in-cljs"
"cljx"
"clojure.pprint feature"
"compile to llvm"
"compiling to asm.js"
"defonce"
"drop the JVM dependency"
"dynamic namespaces"
"easier to understand compliation errors"
"edn reader, instead of cljs.core/read-string"
"eval"
"eval"
"eval"
"eval"
"eval"
"eval"
"eval - The language is crippled without it.

Without eval debugging will never be happy experience in ClojureScript, it will continue to be incredibly painful (source maps are not a real fully fledged debugger) and time consuming. It also drives away new users.

Aside from debugging, just look at how many alternative REPLs there are. People keep wasting time building hacks upon hacks all of which are hard to use in various ways and ultimately have to be discarded in production. All because of the lack of eval.

I understand the rationale behind not wanting eval. But I (and I'm sure many others) would be happy to give up some performance and code size for a fully functional language.

The software engineering world has already solved this issue quite neatly. For example, instead of just stripping a binary you can split it into debugging information and a stripped binary. ClojureScript could do this, and generate two files. When the second is loaded eval could be used. The best of both worlds."
"eval and proper macros"
"faster compilation"
"feature expressions"
"feature expressions"
"feature expressions"
"feature expressions"
"feature expressions"
"feature expressions (this is actually viable not only for clojurescript)"
"first classe iterators (i might simply not have found them)"
"good REPL"
"himera-style repl for use in browser console like cleverFnName("(console/log \"hello\")""
"i have no idea"
"integrated testing framework with core.async support."
"interactive debugger (in cljs, rather than compiled js)"
"macros"
"macros"
"nil"
"node.js integration support"
"official cljx compiler"
"predicate dispatch"
"pretty-printing (come on fipp!)"
"promises"
"proper auto completion including dom elements."
"really expect a significantly smaller js output"
"reified namespaces"
"self hosting"
"self-hosting compiler"
"some sense of sanity"
"something to bridge the gap in the lack of 'eval'"
"stability"
"tco"
"the language itself is fine, but I'd like the error messages both at compile time and at run-time to be more human-friendly. Often times, they don't make a whole lot of sense, and things fail in larger "intervals" or chunks than I'd hope. 

I'd also like the compiler to do a better job of verifying correctness. Right now, I still get a lot of runtime errors for things that the compiler could or should catch (things like calling a function with the wrong number of arguments, for example)"